prepare release

fix h2 compatibility
update changelog
2025-08-19 20:35:36 +02:00 · 2018-07-11 13:27:50 +06:00 · 2018-07-11 13:26:51 +06:00 · 2018-07-11 13:26:40 +06:00 · 2018-06-25 19:37:24 +03:00 · 2018-06-21 09:47:46 +06:00
305 changed files with 34313 additions and 50908 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -1,15 +1,37 @@
 environment:
  global:
-    PROJECT_NAME: actix-web
+    PROJECT_NAME: actix
  matrix:
    # Stable channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: 1.24.0
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: 1.24.0
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: 1.24.0
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: 1.24.0
+    # Stable channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: stable
    - TARGET: i686-pc-windows-msvc
      CHANNEL: stable
    - TARGET: x86_64-pc-windows-gnu
      CHANNEL: stable
    - TARGET: x86_64-pc-windows-msvc
      CHANNEL: stable
+    # Beta channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: beta
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: beta
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: beta
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: beta
    # Nightly channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: nightly
    - TARGET: i686-pc-windows-msvc
      CHANNEL: nightly
    - TARGET: x86_64-pc-windows-gnu
@@ -37,5 +59,4 @@ build: false

 # Equivalent to Travis' `script` phase
 test_script:
-  - cargo clean
  - cargo test --no-default-features --features="flate2-rust"
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,18 +1,19 @@
 language: rust
-sudo: required
+sudo: false
 dist: trusty

 cache:
-  # cargo: true
+  cargo: true
  apt: true

 matrix:
  include:
+    - rust: 1.24.0
    - rust: stable
    - rust: beta
-    - rust: nightly-2019-08-10
+    - rust: nightly
  allow_failures:
-    - rust: nightly-2019-08-10
+    - rust: nightly

 env:
  global:
@@ -22,37 +23,33 @@ env:
 before_install:
  - sudo add-apt-repository -y ppa:0k53d-karl-f830m/openssl
  - sudo apt-get update -qq
-  - sudo apt-get install -y openssl libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev
-
-before_cache: |
-  if [[ "$TRAVIS_RUST_VERSION" == "nightly-2019-08-10" ]]; then
-    RUSTFLAGS="--cfg procmacro2_semver_exempt" cargo install --version 0.6.11 cargo-tarpaulin
-  fi
+  - sudo apt-get install -qq libssl-dev libelf-dev libdw-dev cmake gcc binutils-dev libiberty-dev

 # Add clippy
 before_script:
  - export PATH=$PATH:~/.cargo/bin

 script:
-  - cargo update
-  - cargo check --all --no-default-features
-  - cargo test --all-features --all -- --nocapture
-  - cd actix-http; cargo test --no-default-features --features="rust-tls" -- --nocapture; cd ..
-  - cd awc; cargo test --no-default-features --features="rust-tls" -- --nocapture; cd ..
+  - |
+    if [[ "$TRAVIS_RUST_VERSION" != "1.24.0" ]]; then
+    cargo clean
+    cargo test --features="alpn,tls" -- --nocapture
+    fi
+  - |
+    if [[ "$TRAVIS_RUST_VERSION" == "1.24.0" ]]; then
+    bash <(curl https://raw.githubusercontent.com/xd009642/tarpaulin/master/travis-install.sh)
+    USE_SKEPTIC=1 cargo tarpaulin --out Xml --no-count
+    bash <(curl -s https://codecov.io/bash)
+    echo "Uploaded code coverage"
+    fi

 # Upload docs
 after_success:
  - |
    if [[ "$TRAVIS_OS_NAME" == "linux" && "$TRAVIS_PULL_REQUEST" = "false" && "$TRAVIS_BRANCH" == "master" && "$TRAVIS_RUST_VERSION" == "stable" ]]; then
-      cargo doc --no-deps --all-features &&
+      cargo doc --features "alpn, tls, session" --no-deps &&
      echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html &&
      git clone https://github.com/davisp/ghp-import.git &&
      ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://"$GH_TOKEN"@github.com/"$TRAVIS_REPO_SLUG.git" target/doc &&
      echo "Uploaded documentation"
    fi
-  - |
-    if [[ "$TRAVIS_RUST_VERSION" ==  "nightly-2019-08-10" ]]; then
-        taskset -c 0 cargo tarpaulin --out Xml --all --all-features
-        bash <(curl -s https://codecov.io/bash)
-        echo "Uploaded code coverage"
-    fi
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,347 +1,465 @@
 # Changes

-## [1.0.9] - 2019-xx-xx
-
-### Added
-
-* Add `Payload::into_inner` method and make stored `def::Payload` public. (#1110)
-
-### Changed
-
-* Support `Host` guards when the `Host` header is unset (e.g. HTTP/2 requests) (#1129)
-
-## [1.0.8] - 2019-09-25
-
-### Added
-
-* Add `Scope::register_data` and `Resource::register_data` methods, parallel to
-  `App::register_data`.
-
-* Add `middleware::Condition` that conditionally enables another middleware
-
-* Allow to re-construct `ServiceRequest` from `HttpRequest` and `Payload`
-
-* Add `HttpServer::listen_uds` for ability to listen on UDS FD rather than path,
-  which is useful for example with systemd.
-
-### Changed
-
-* Make UrlEncodedError::Overflow more informativve
-
-* Use actix-testing for testing utils
-
-
-## [1.0.7] - 2019-08-29
+## [0.6.15] - 2018-07-11

 ### Fixed

-* Request Extensions leak #1062
+* Fix h2 compatibility #352
+
+* Fix duplicate tail of StaticFiles with index_file. #344


-## [1.0.6] - 2019-08-28
+## [0.6.14] - 2018-06-21

 ### Added

-* Re-implement Host predicate (#989)
-
-* Form immplements Responder, returning a `application/x-www-form-urlencoded` response
-
-* Add `into_inner` to `Data`
-
-* Add `test::TestRequest::set_form()` convenience method to automatically serialize data and set
-  the header in test requests.
-
-### Changed
-
-* `Query` payload made `pub`. Allows user to pattern-match the payload.
-
-* Enable `rust-tls` feature for client #1045
-
-* Update serde_urlencoded to 0.6.1
-
-* Update url to 2.1
-
-
-## [1.0.5] - 2019-07-18
-
-### Added
-
-* Unix domain sockets (HttpServer::bind_uds) #92
-
-* Actix now logs errors resulting in "internal server error" responses always, with the `error`
-  logging level
+* Allow to disable masking for websockets client

 ### Fixed

-* Restored logging of errors through the `Logger` middleware
+* SendRequest execution fails with the "internal error: entered unreachable code" #329


-## [1.0.4] - 2019-07-17
-
-### Added
-
-* Add `Responder` impl for `(T, StatusCode) where T: Responder`
-
-* Allow to access app's resource map via
-  `ServiceRequest::resource_map()` and `HttpRequest::resource_map()` methods.
-
-### Changed
-
-* Upgrade `rand` dependency version to 0.7
-
-
-## [1.0.3] - 2019-06-28
-
-### Added
-
-* Support asynchronous data factories #850
-
-### Changed
-
-*  Use `encoding_rs` crate instead of unmaintained `encoding` crate
-
-
-## [1.0.2] - 2019-06-17
-
-### Changed
-
-* Move cors middleware to `actix-cors` crate.
-
-* Move identity middleware to `actix-identity` crate.
-
-
-## [1.0.1] - 2019-06-17
-
-### Added
-
-* Add support for PathConfig #903
-
-* Add `middleware::identity::RequestIdentity` trait to `get_identity` from `HttpMessage`.
-
-### Changed
-
-* Move cors middleware to `actix-cors` crate.
-
-* Move identity middleware to `actix-identity` crate.
-
-* Disable default feature `secure-cookies`.
-
-* Allow to test an app that uses async actors #897
-
-* Re-apply patch from #637 #894
+## [0.6.13] - 2018-06-13

 ### Fixed

-* HttpRequest::url_for is broken with nested scopes #915
+* http/2 end-of-frame is not set if body is empty bytes #307
+
+* InternalError can trigger memory unsafety #301
+
+* Fix docs.rs build


-## [1.0.0] - 2019-06-05
+## [0.6.12] - 2018-06-08

 ### Added

-* Add `Scope::configure()` method.
+* Add `Host` filter #287

-* Add `ServiceRequest::set_payload()` method.
+* Allow to filter applications

-* Add `test::TestRequest::set_json()` convenience method to automatically
-  serialize data and set header in test requests.
+* Improved failure interoperability with downcasting #285

-* Add macros for head, options, trace, connect and patch http methods
+* Allow to use custom resolver for `ClientConnector`

-### Changed

-* Drop an unnecessary `Option<_>` indirection around `ServerBuilder` from `HttpServer`. #863
+### Deprecated
+
+* `Error::cause()` and introduces failure interoperability functions and downcasting.
+
+
+## [0.6.11] - 2018-06-05

 ### Fixed

-* Fix Logger request time format, and use rfc3339. #867
+* Support chunked encoding for UrlEncoded body #262

-* Clear http requests pool on app service drop #860
+* `HttpRequest::url_for()` for a named route with no variables segments #265
+
+* `Middleware::response()` is not invoked if error result was returned by another `Middleware::start()` #255
+
+* CORS: Do not validate Origin header on non-OPTION requests #271
+
+* Fix multipart upload "Incomplete" error #282


-## [1.0.0-rc] - 2019-05-18
+## [0.6.10] - 2018-05-24

-### Add
+### Added

-* Add `Query<T>::from_query()` to extract parameters from a query string. #846
-* `QueryConfig`, similar to `JsonConfig` for customizing error handling of query extractors.
+* Allow to use path without traling slashes for scope registration #241

-### Changed
-
-* `JsonConfig` is now `Send + Sync`, this implies that `error_handler` must be `Send + Sync` too.
+* Allow to set encoding for exact NamedFile #239

 ### Fixed

-* Codegen with parameters in the path only resolves the first registered endpoint #841
+* `TestServer::post()` actually sends `GET` request #240


-## [1.0.0-beta.4] - 2019-05-12
+## 0.6.9 (2018-05-22)

-### Add
+* Drop connection if request's payload is not fully consumed #236

-* Allow to set/override app data on scope level
+* Fix streaming response with body compression

-### Changed

-* `App::configure` take an `FnOnce` instead of `Fn`
-* Upgrade actix-net crates
+## 0.6.8 (2018-05-20)

+* Fix scope resource path extractor #234

-## [1.0.0-beta.3] - 2019-05-04
+* Re-use tcp listener on pause/resume

-### Added

-* Add helper function for executing futures `test::block_fn()`
+## 0.6.7 (2018-05-17)

-### Changed
+* Fix compilation with --no-default-features

-* Extractor configuration could be registered with `App::data()`
-  or with `Resource::data()` #775

-* Route data is unified with app data, `Route::data()` moved to resource
-  level to `Resource::data()`
+## 0.6.6 (2018-05-17)

-* CORS handling without headers #702
+* Panic during middleware execution #226

-* Allow to construct `Data` instances to avoid double `Arc` for `Send + Sync` types.
+* Add support for listen_tls/listen_ssl #224

-### Fixed
+* Implement extractor for `Session`

-* Fix `NormalizePath` middleware impl #806
+* Ranges header support for NamedFile #60

-### Deleted

-* `App::data_factory()` is deleted.
+## 0.6.5 (2018-05-15)

+* Fix error handling during request decoding #222

-## [1.0.0-beta.2] - 2019-04-24

-### Added
+## 0.6.4 (2018-05-11)

-* Add raw services support via `web::service()`
+* Fix segfault in ServerSettings::get_response_builder()

-* Add helper functions for reading response body `test::read_body()`

-* Add support for `remainder match` (i.e "/path/{tail}*")
+## 0.6.3 (2018-05-10)

-* Extend `Responder` trait, allow to override status code and headers.
+* Add `Router::with_async()` method for async handler registration.

-* Store visit and login timestamp in the identity cookie #502
+* Added error response functions for 501,502,503,504

-### Changed
+* Fix client request timeout handling

-* `.to_async()` handler can return `Responder` type #792

-### Fixed
+## 0.6.2 (2018-05-09)

-* Fix async web::Data factory handling
+* WsWriter trait is optional.


-## [1.0.0-beta.1] - 2019-04-20
+## 0.6.1 (2018-05-08)

-### Added
+* Fix http/2 payload streaming #215

-* Add helper functions for reading test response body,
- `test::read_response()` and test::read_response_json()`
+* Fix connector's default `keep-alive` and `lifetime` settings #212

-* Add `.peer_addr()` #744
+* Send `ErrorNotFound` instead of `ErrorBadRequest` when path extractor fails #214

-* Add `NormalizePath` middleware
+* Allow to exclude certain endpoints from logging #211

-### Changed

-* Rename `RouterConfig` to `ServiceConfig`
+## 0.6.0 (2018-05-08)

-* Rename `test::call_success` to `test::call_service`
+* Add route scopes #202

-* Removed `ServiceRequest::from_parts()` as it is unsafe to create from parts.
+* Allow to use ssl and non-ssl connections at the same time #206

-* `CookieIdentityPolicy::max_age()` accepts value in seconds
+* Websocket CloseCode Empty/Status is ambiguous #193

-### Fixed
+* Add Content-Disposition to NamedFile #204

-* Fixed `TestRequest::app_data()`
+* Allow to access Error's backtrace object

+* Allow to override files listing renderer for `StaticFiles` #203

-## [1.0.0-alpha.6] - 2019-04-14
+* Various extractor usability improvements #207

-### Changed

-* Allow to use any service as default service.
+## 0.5.6 (2018-04-24)

-* Remove generic type for request payload, always use default.
+* Make flate2 crate optional #200

-* Removed `Decompress` middleware. Bytes, String, Json, Form extractors
-  automatically decompress payload.

-* Make extractor config type explicit. Add `FromRequest::Config` associated type.
+## 0.5.5 (2018-04-24)

+* Fix panic when Websocket is closed with no error code #191

-## [1.0.0-alpha.5] - 2019-04-12
+* Allow to use rust backend for flate2 crate #199

-### Added
+## 0.5.4 (2018-04-19)

-* Added async io `TestBuffer` for testing.
+* Add identity service middleware

-### Deleted
+* Middleware response() is not invoked if there was an error in async handler #187

-* Removed native-tls support
+* Use Display formatting for InternalError Display implementation #188


-## [1.0.0-alpha.4] - 2019-04-08
+## 0.5.3 (2018-04-18)

-### Added
+* Impossible to quote slashes in path parameters #182

-* `App::configure()` allow to offload app configuration to different methods

-* Added `URLPath` option for logger
+## 0.5.2 (2018-04-16)

-* Added `ServiceRequest::app_data()`, returns `Data<T>`
+* Allow to configure StaticFiles's CpuPool, via static method or env variable

-* Added `ServiceFromRequest::app_data()`, returns `Data<T>`
+* Add support for custom handling of Json extractor errors #181

-### Changed
+* Fix StaticFiles does not support percent encoded paths #177

-* `FromRequest` trait refactoring
+* Fix Client Request with custom Body Stream halting on certain size requests #176

-* Move multipart support to actix-multipart crate

-### Fixed
+## 0.5.1 (2018-04-12)

-* Fix body propagation in Response::from_error. #760
+* Client connector provides stats, `ClientConnector::stats()`

+* Fix end-of-stream handling in parse_payload #173

-## [1.0.0-alpha.3] - 2019-04-02
+* Fix StaticFiles generate a lot of threads #174

-### Changed

-* Renamed `TestRequest::to_service()` to `TestRequest::to_srv_request()`
+## 0.5.0 (2018-04-10)

-* Renamed `TestRequest::to_response()` to `TestRequest::to_srv_response()`
+* Type-safe path/query/form parameter handling, using serde #70

-* Removed `Deref` impls
+* HttpResponse builder's methods  `.body()`, `.finish()`, `.json()`
+  return `HttpResponse` instead of `Result`

-### Removed
+* Use more ergonomic `actix_web::Error` instead of `http::Error` for `ClientRequestBuilder::body()`

-* Removed unused `actix_web::web::md()`
+* Added `signed` and `private` `CookieSessionBackend`s

+* Added `HttpRequest::resource()`, returns current matched resource

-## [1.0.0-alpha.2] - 2019-03-29
+* Added `ErrorHandlers` middleware

-### Added
+* Fix router cannot parse Non-ASCII characters in URL #137

-* rustls support
+* Fix client connection pooling

-### Changed
+* Fix long client urls #129

-* use forked cookie
+* Fix panic on invalid URL characters #130

-* multipart::Field renamed to MultipartField
+* Fix logger request duration calculation #152

-## [1.0.0-alpha.1] - 2019-03-28
+* Fix prefix and static file serving #168

-### Changed

-* Complete architecture re-design.
+## 0.4.10 (2018-03-20)

-* Return 405 response if no matching route found within resource #538
+* Use `Error` instead of `InternalError` for `error::ErrorXXXX` methods
+
+* Allow to set client request timeout
+
+* Allow to set client websocket handshake timeout
+
+* Refactor `TestServer` configuration
+
+* Fix server websockets big payloads support
+
+* Fix http/2 date header generation
+
+
+## 0.4.9 (2018-03-16)
+
+* Allow to disable http/2 support
+
+* Wake payload reading task when data is available
+
+* Fix server keep-alive handling
+
+* Send Query Parameters in client requests #120
+
+* Move brotli encoding to a feature
+
+* Add option of default handler for `StaticFiles` handler #57
+
+* Add basic client connection pooling
+
+
+## 0.4.8 (2018-03-12)
+
+* Allow to set read buffer capacity for server request
+
+* Handle WouldBlock error for socket accept call
+
+
+## 0.4.7 (2018-03-11)
+
+* Fix panic on unknown content encoding
+
+* Fix connection get closed too early
+
+* Fix streaming response handling for http/2
+
+* Better sleep on error support
+
+
+## 0.4.6 (2018-03-10)
+
+* Fix client cookie handling
+
+* Fix json content type detection
+
+* Fix CORS middleware #117
+
+* Optimize websockets stream support
+
+
+## 0.4.5 (2018-03-07)
+
+* Fix compression #103 and #104
+
+* Fix client cookie handling #111
+
+* Non-blocking processing of a `NamedFile`
+
+* Enable compression support for `NamedFile`
+
+* Better support for `NamedFile` type
+
+* Add `ResponseError` impl for `SendRequestError`. This improves ergonomics of the client.
+
+* Add native-tls support for client
+
+* Allow client connection timeout to be set #108
+
+* Allow to use std::net::TcpListener for HttpServer
+
+* Handle panics in worker threads
+
+
+## 0.4.4 (2018-03-04)
+
+* Allow to use Arc<Vec<u8>> as response/request body
+
+* Fix handling of requests with an encoded body with a length > 8192 #93
+
+## 0.4.3 (2018-03-03)
+
+* Fix request body read bug
+
+* Fix segmentation fault #79
+
+* Set reuse address before bind #90
+
+
+## 0.4.2 (2018-03-02)
+
+* Better naming for websockets implementation
+
+* Add `Pattern::with_prefix()`, make it more usable outside of actix
+
+* Add csrf middleware for filter for cross-site request forgery #89
+
+* Fix disconnect on idle connections
+
+
+## 0.4.1 (2018-03-01)
+
+* Rename `Route::p()` to `Route::filter()`
+
+* Better naming for http codes
+
+* Fix payload parse in situation when socket data is not ready.
+
+* Fix Session mutable borrow lifetime #87
+
+
+## 0.4.0 (2018-02-28)
+
+* Actix 0.5 compatibility
+
+* Fix request json/urlencoded loaders
+
+* Simplify HttpServer type definition
+
+* Added HttpRequest::encoding() method
+
+* Added HttpRequest::mime_type() method
+
+* Added HttpRequest::uri_mut(), allows to modify request uri
+
+* Added StaticFiles::index_file()
+
+* Added http client
+
+* Added websocket client
+
+* Added TestServer::ws(), test websockets client
+
+* Added TestServer http client support
+
+* Allow to override content encoding on application level
+
+
+## 0.3.3 (2018-01-25)
+
+* Stop processing any events after context stop
+
+* Re-enable write back-pressure for h1 connections
+
+* Refactor HttpServer::start_ssl() method
+
+* Upgrade openssl to 0.10
+
+
+## 0.3.2 (2018-01-21)
+
+* Fix HEAD requests handling
+
+* Log request processing errors
+
+* Always enable content encoding if encoding explicitly selected
+
+* Allow multiple Applications on a single server with different state #49
+
+* CORS middleware: allowed_headers is defaulting to None #50
+
+
+## 0.3.1 (2018-01-13)
+
+* Fix directory entry path #47
+
+* Do not enable chunked encoding for HTTP/1.0
+
+* Allow explicitly disable chunked encoding
+
+
+## 0.3.0 (2018-01-12)
+
+* HTTP/2 Support
+
+* Refactor streaming responses
+
+* Refactor error handling
+
+* Asynchronous middlewares
+
+* Refactor logger middleware
+
+* Content compression/decompression (br, gzip, deflate)
+
+* Server multi-threading
+
+* Gracefull shutdown support
+
+
+## 0.2.1 (2017-11-03)
+
+* Allow to start tls server with `HttpServer::serve_tls`
+
+* Export `Frame` enum
+
+* Add conversion impl from `HttpResponse` and `BinaryBody` to a `Frame`
+
+
+## 0.2.0 (2017-10-30)
+
+* Do not use `http::Uri` as it can not parse some valid paths
+
+* Refactor response `Body`
+
+* Refactor `RouteRecognizer` usability
+
+* Refactor `HttpContext::write`
+
+* Refactor `Payload` stream
+
+* Re-use `BinaryBody` for `Frame::Payload`
+
+* Stop http actor on `write_eof`
+
+* Fix disconnection handling.
+
+
+## 0.1.0 (2017-10-23)
+
+* First release
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,133 +1,119 @@
 [package]
 name = "actix-web"
-version = "1.0.8"
+version = "0.6.15"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
-keywords = ["actix", "http", "web", "framework", "async"]
+keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
 documentation = "https://docs.rs/actix-web/"
 categories = ["network-programming", "asynchronous",
              "web-programming::http-server",
+              "web-programming::http-client",
              "web-programming::websocket"]
 license = "MIT/Apache-2.0"
 exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
-edition = "2018"
-
-[package.metadata.docs.rs]
-features = ["ssl", "brotli", "flate2-zlib", "secure-cookies", "client", "rust-tls", "uds"]
+build = "build.rs"

 [badges]
 travis-ci = { repository = "actix/actix-web", branch = "master" }
+appveyor = { repository = "fafhrd91/actix-web-hdy9d" }
 codecov = { repository = "actix/actix-web", branch = "master", service = "github" }

 [lib]
 name = "actix_web"
 path = "src/lib.rs"

-[workspace]
-members = [
-  ".",
-  "awc",
-  "actix-http",
-  "actix-cors",
-  "actix-files",
-  "actix-framed",
-  "actix-session",
-  "actix-identity",
-  "actix-multipart",
-  "actix-web-actors",
-  "actix-web-codegen",
-  "test-server",
-]
-
 [features]
-default = ["brotli", "flate2-zlib", "client", "fail"]
+default = ["session", "brotli", "flate2-c"]

-# http client
-client = ["awc"]
-
-# brotli encoding, requires c compiler
-brotli = ["actix-http/brotli"]
-
-# miniz-sys backend for flate2 crate
-flate2-zlib = ["actix-http/flate2-zlib"]
-
-# rust backend for flate2 crate
-flate2-rust = ["actix-http/flate2-rust"]
-
-# sessions feature, session require "ring" crate and c compiler
-secure-cookies = ["actix-http/secure-cookies"]
-
-fail = ["actix-http/fail"]
+# tls
+tls = ["native-tls", "tokio-tls"]

 # openssl
-ssl = ["openssl", "actix-server/ssl", "awc/ssl"]
+alpn = ["openssl", "tokio-openssl"]

-# rustls
-rust-tls = ["rustls", "actix-server/rust-tls", "awc/rust-tls"]
+# sessions feature, session require "ring" crate and c compiler
+session = ["cookie/secure"]

-# unix domain sockets support
-uds = ["actix-server/uds"]
+# brotli encoding, requires c compiler
+brotli = ["brotli2"]
+
+# miniz-sys backend for flate2 crate
+flate2-c = ["flate2/miniz-sys"]
+
+# rust backend for flate2 crate
+flate2-rust = ["flate2/rust_backend"]
+
+[package.metadata.docs.rs]
+features = ["tls", "alpn", "session", "brotli", "flate2-c"]

 [dependencies]
-actix-codec = "0.1.2"
-actix-service = "0.4.1"
-actix-utils = "0.4.4"
-actix-router = "0.1.5"
-actix-rt = "0.2.4"
-actix-web-codegen = "0.1.2"
-actix-http = "0.2.9"
-actix-server = "0.6.1"
-actix-server-config = "0.1.2"
-actix-testing = "0.1.0"
-actix-threadpool = "0.1.1"
-awc = { version = "0.2.7", optional = true }
+actix = "^0.5.8"

-bytes = "0.4"
-derive_more = "0.15.0"
-encoding_rs = "0.8"
-futures = "0.1.25"
-hashbrown = "0.6.3"
+base64 = "0.9"
+bitflags = "1.0"
+failure = "0.1.1"
+h2 = "0.1"
+http = "^0.1.5"
+httparse = "1.2"
+http-range = "0.1"
+libc = "0.2"
 log = "0.4"
 mime = "0.3"
-net2 = "0.2.33"
-parking_lot = "0.9"
+mime_guess = "2.0.0-alpha"
+num_cpus = "1.0"
+percent-encoding = "1.0"
+rand = "0.4"
 regex = "1.0"
-serde = { version = "1.0", features=["derive"] }
+serde = "1.0"
 serde_json = "1.0"
-serde_urlencoded = "0.6.1"
-time = "0.1.42"
-url = "2.1"
+serde_urlencoded = "0.5"
+sha1 = "0.6"
+smallvec = "0.6"
+time = "0.1"
+encoding = "0.2"
+language-tags = "0.2"
+lazy_static = "1.0"
+url = { version="1.7", features=["query_encoding"] }
+cookie = { version="0.10", features=["percent-encode"] }
+brotli2 = { version="^0.3.2", optional = true }
+flate2 = { version="1.0", optional = true, default-features = false }

-# ssl support
+# io
+mio = "^0.6.13"
+net2 = "0.2"
+bytes = "0.4"
+byteorder = "1"
+futures = "0.1"
+futures-cpupool = "0.1"
+slab = "0.4"
+tokio-io = "0.1"
+tokio-core = "0.1"
+
+# native-tls
+native-tls = { version="0.1", optional = true }
+tokio-tls = { version="0.1", optional = true }
+
+# openssl
 openssl = { version="0.10", optional = true }
-rustls = { version = "0.15", optional = true }
+tokio-openssl = { version="0.2", optional = true }

 [dev-dependencies]
-actix = "0.8.3"
-actix-connect = "0.2.2"
-actix-http-test = "0.2.4"
-rand = "0.7"
-env_logger = "0.6"
+env_logger = "0.5"
 serde_derive = "1.0"
-tokio-timer = "0.2.8"
-brotli2 = "0.3.2"
-flate2 = "1.0.2"
+
+[build-dependencies]
+version_check = "0.1"

 [profile.release]
 lto = true
 opt-level = 3
 codegen-units = 1

-[patch.crates-io]
-actix-web = { path = "." }
-actix-http = { path = "actix-http" }
-actix-http-test = { path = "test-server" }
-actix-web-codegen = { path = "actix-web-codegen" }
-actix-web-actors = { path = "actix-web-actors" }
-actix-session = { path = "actix-session" }
-actix-files = { path = "actix-files" }
-actix-multipart = { path = "actix-multipart" }
-awc = { path = "awc" }
+[workspace]
+members = [
+  "./",
+  "tools/wsload/",
+]
--- a/MIGRATION.md
+++ b/MIGRATION.md
@@ -1,469 +1,4 @@
-## 1.0.1
-
-* Cors middleware has been moved to `actix-cors` crate
-
-  instead of
-
-  ```rust
-  use actix_web::middleware::cors::Cors;
-  ```
-
-  use
-
-  ```rust
-  use actix_cors::Cors;
-  ```
-
-* Identity middleware has been moved to `actix-identity` crate
-
-  instead of
-
-  ```rust
-  use actix_web::middleware::identity::{Identity, CookieIdentityPolicy, IdentityService};
-  ```
-
-  use
-
-  ```rust
-  use actix_identity::{Identity, CookieIdentityPolicy, IdentityService};
-  ```
-
-
-## 1.0.0
-
-* Extractor configuration. In version 1.0 this is handled with the new `Data` mechanism for both setting and retrieving the configuration
-
-  instead of
-    
-  ```rust
-    
-  #[derive(Default)]
-  struct ExtractorConfig {
-     config: String,
-  }
-    
-  impl FromRequest for YourExtractor {
-     type Config = ExtractorConfig;
-     type Result = Result<YourExtractor, Error>;
-  
-     fn from_request(req: &HttpRequest, cfg: &Self::Config) -> Self::Result {
-         println!("use the config: {:?}", cfg.config);
-         ...
-     }
-  }
-    
-  App::new().resource("/route_with_config", |r| {
-     r.post().with_config(handler_fn, |cfg| {
-         cfg.0.config = "test".to_string();
-     })
-  })
-    
-  ```
-    
-  use the HttpRequest to get the configuration like any other `Data` with `req.app_data::<C>()` and set it with the `data()` method on the `resource`
-    
-  ```rust
-  #[derive(Default)]
-  struct ExtractorConfig {
-     config: String,
-  }
-    
-  impl FromRequest for YourExtractor {
-     type Error = Error;
-     type Future = Result<Self, Self::Error>;
-     type Config = ExtractorConfig;
-    
-     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
-         let cfg = req.app_data::<ExtractorConfig>();
-         println!("config data?: {:?}", cfg.unwrap().role);
-         ...
-     }
-  }
-    
-  App::new().service(
-     resource("/route_with_config")
-         .data(ExtractorConfig {
-             config: "test".to_string(),
-         })
-         .route(post().to(handler_fn)),
-  )
-  ```
-  
-* Resource registration. 1.0 version uses generalized resource
-  registration via `.service()` method.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.f(welcome))
-  ```
-
-  use App's or Scope's `.service()` method. `.service()` method accepts
-  object that implements `HttpServiceFactory` trait. By default
-  actix-web provides `Resource` and `Scope` services.
-
-  ```rust
-    App.new().service(
-        web::resource("/welcome")
-            .route(web::get().to(welcome))
-            .route(web::post().to(post_handler))
-  ```
-
-* Scope registration.
-
-  instead of
-
-  ```rust
-      let app = App::new().scope("/{project_id}", |scope| {
-            scope
-                .resource("/path1", |r| r.f(|_| HttpResponse::Ok()))
-                .resource("/path2", |r| r.f(|_| HttpResponse::Ok()))
-                .resource("/path3", |r| r.f(|_| HttpResponse::MethodNotAllowed()))
-      });
-  ```
-
-  use `.service()` for registration and `web::scope()` as scope object factory.
-
-  ```rust
-      let app = App::new().service(
-          web::scope("/{project_id}")
-              .service(web::resource("/path1").to(|| HttpResponse::Ok()))
-              .service(web::resource("/path2").to(|| HttpResponse::Ok()))
-              .service(web::resource("/path3").to(|| HttpResponse::MethodNotAllowed()))
-      );
-  ```
-
-* `.with()`, `.with_async()` registration methods have been renamed to `.to()` and `.to_async()`.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.with(welcome))
-  ```
-
-  use `.to()` or `.to_async()` methods
-
-  ```rust
-    App.new().service(web::resource("/welcome").to(welcome))
-  ```
-
-* Passing arguments to handler with extractors, multiple arguments are allowed
-
-  instead of
-
-  ```rust
-  fn welcome((body, req): (Bytes, HttpRequest)) -> ... {
-    ...
-  }
-  ```
-
-  use multiple arguments
-
-  ```rust
-  fn welcome(body: Bytes, req: HttpRequest) -> ... {
-    ...
-  }
-  ```
-
-* `.f()`, `.a()` and `.h()` handler registration methods have been removed.
-  Use `.to()` for handlers and `.to_async()` for async handlers. Handler function
-  must use extractors.
-
-  instead of
-
-  ```rust
-    App.new().resource("/welcome", |r| r.f(welcome))
-  ```
-
-  use App's `to()` or `to_async()` methods
-
-  ```rust
-    App.new().service(web::resource("/welcome").to(welcome))
-  ```
-
-* `HttpRequest` does not provide access to request's payload stream.
-
-  instead of
-
-  ```rust
-  fn index(req: &HttpRequest) -> Box<Future<Item=HttpResponse, Error=Error>> {
-    req
-       .payload()
-       .from_err()
-       .fold((), |_, chunk| {
-            ...
-        })
-       .map(|_| HttpResponse::Ok().finish())
-       .responder()
-  }
-  ```
-
-  use `Payload` extractor
-
-  ```rust
-  fn index(stream: web::Payload) -> impl Future<Item=HttpResponse, Error=Error> {
-     stream
-       .from_err()
-       .fold((), |_, chunk| {
-            ...
-        })
-       .map(|_| HttpResponse::Ok().finish())
-  }
-  ```
-
-* `State` is now `Data`.  You register Data during the App initialization process
-  and then access it from handlers either using a Data extractor or using
-  HttpRequest's api.
-
-  instead of
-
-  ```rust
-    App.with_state(T)
-  ```
-
-  use App's `data` method
-
-  ```rust
-	App.new()
-       .data(T)
-  ```
-
-  and either use the Data extractor within your handler
-
-  ```rust
-    use actix_web::web::Data;
-
-	fn endpoint_handler(Data<T>)){
-      ...
-    }
-  ```
-
-  .. or access your Data element from the HttpRequest
-
-  ```rust
-	fn endpoint_handler(req: HttpRequest) {
-		let data: Option<Data<T>> = req.app_data::<T>();
-    }
-  ```
-
-
-* AsyncResponder is removed, use `.to_async()` registration method and `impl Future<>` as result type.
-
-  instead of
-
-  ```rust
-	use actix_web::AsyncResponder;
-
-    fn endpoint_handler(...) -> impl Future<Item=HttpResponse, Error=Error>{
-		...
-        .responder()
-	}
-  ```
-
-  .. simply omit AsyncResponder and the corresponding responder() finish method
-
-
-* Middleware
-
-  instead of
-
-  ```rust
-      let app = App::new()
-           .middleware(middleware::Logger::default())
-  ```
-
-  use `.wrap()` method
-
-  ```rust
-      let app = App::new()
-           .wrap(middleware::Logger::default())
-           .route("/index.html", web::get().to(index));
-  ```
-
-* `HttpRequest::body()`, `HttpRequest::urlencoded()`, `HttpRequest::json()`, `HttpRequest::multipart()`
-  method have been removed. Use `Bytes`, `String`, `Form`, `Json`, `Multipart` extractors instead.
-
-  instead of
-
-  ```rust
-  fn index(req: &HttpRequest) -> Responder {
-     req.body()
-       .and_then(|body| {
-          ...
-       })
-  }
-  ```
-
-  use
-
-  ```rust
-  fn index(body: Bytes) -> Responder {
-     ...
-  }
-  ```
-
-* `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type
-
-* StaticFiles and NamedFile has been move to separate create.
-
-  instead of `use actix_web::fs::StaticFile`
-
-  use `use actix_files::Files`
-
-  instead of `use actix_web::fs::Namedfile`
-
-  use `use actix_files::NamedFile`
-
-* Multipart has been move to separate create.
-
-  instead of `use actix_web::multipart::Multipart`
-
-  use `use actix_multipart::Multipart`
-
-* Response compression is not enabled by default.
-  To enable, use `Compress` middleware, `App::new().wrap(Compress::default())`.
-
-* Session middleware moved to actix-session crate
-
-* Actors support have been moved to `actix-web-actors` crate
-
-* Custom Error
-
-  Instead of error_response method alone, ResponseError now provides two methods: error_response and render_response respectively. Where, error_response creates the error response and render_response returns the error response to the caller. 
-
-  Simplest migration from 0.7 to 1.0 shall include below method to the custom implementation of ResponseError:
-
-  ```rust
-  fn render_response(&self) -> HttpResponse {
-    self.error_response()
-  }
-  ```
-
-## 0.7.15
-
-* The `' '` character is not percent decoded anymore before matching routes. If you need to use it in
-  your routes, you should use `%20`.
-
-  instead of
-
-    ```rust
-    fn main() {
-         let app = App::new().resource("/my index", |r| {
-             r.method(http::Method::GET)
-                    .with(index);
-         });
-    }
-    ```
-
-  use
-
-    ```rust
-    fn main() {
-         let app = App::new().resource("/my%20index", |r| {
-             r.method(http::Method::GET)
-                    .with(index);
-         });
-    }
-    ```
-
-* If you used `AsyncResult::async` you need to replace it with `AsyncResult::future`
-
-
-## 0.7.4
-
-* `Route::with_config()`/`Route::with_async_config()` always passes configuration objects as tuple
-  even for handler with one parameter.
-
-
-## 0.7
-
-* `HttpRequest` does not implement `Stream` anymore. If you need to read request payload
-  use `HttpMessage::payload()` method.
-  
-  instead of
-  
-    ```rust
-    fn index(req: HttpRequest) -> impl Responder {
-         req
-            .from_err()
-            .fold(...)
-            ....
-    }
-    ```
-
-  use `.payload()`
-
-    ```rust
-    fn index(req: HttpRequest) -> impl Responder {
-         req
-            .payload()  // <- get request payload stream
-            .from_err()
-            .fold(...)
-            ....
-    }
-    ```
-
-* [Middleware](https://actix.rs/actix-web/actix_web/middleware/trait.Middleware.html)
-  trait uses `&HttpRequest` instead of `&mut HttpRequest`.
-
-* Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
-    
-    instead of 
-
-    ```rust
-    fn index(query: Query<..>, info: Json<MyStruct) -> impl Responder {}
-    ```
-
-    use tuple of extractors and use `.with()` for registration:
-
-    ```rust
-    fn index((query, json): (Query<..>, Json<MyStruct)) -> impl Responder {}
-    ```
-
-* `Handler::handle()` uses `&self` instead of `&mut self`
-
-* `Handler::handle()` accepts reference to `HttpRequest<_>` instead of value
-
-* Removed deprecated `HttpServer::threads()`, use 
-  [HttpServer::workers()](https://actix.rs/actix-web/actix_web/server/struct.HttpServer.html#method.workers) instead.
-
-* Renamed `client::ClientConnectorError::Connector` to
-  `client::ClientConnectorError::Resolver`
-
-* `Route::with()` does not return `ExtractorConfig`, to configure
-  extractor use `Route::with_config()`
-
-    instead of 
-
-    ```rust
-    fn main() {
-         let app = App::new().resource("/index.html", |r| {
-             r.method(http::Method::GET)
-                    .with(index)
-                    .limit(4096);  // <- limit size of the payload
-         });
-    }
-    ```
-    
-    use 
-    
-    ```rust
-  
-    fn main() {
-         let app = App::new().resource("/index.html", |r| {
-             r.method(http::Method::GET)
-                    .with_config(index, |cfg| { // <- register handler
-                       cfg.limit(4096);  // <- limit size of the payload
-                     })
-         });
-    }
-    ```
-
-* `Route::with_async()` does not return `ExtractorConfig`, to configure
-  extractor use `Route::with_async_config()`
-
-
-## 0.6
+## Migration from 0.5 to 0.6

 * `Path<T>` extractor return `ErrorNotFound` on failure instead of `ErrorBadRequest`

@@ -515,7 +50,7 @@
  you need to use `use actix_web::ws::WsWriter`


-## 0.5
+## Migration from 0.4 to 0.5

 * `HttpResponseBuilder::body()`, `.finish()`, `.json()`
   methods return `HttpResponse` instead of `Result<HttpResponse>`
--- a/14
+++ b/14
@@ -0,0 +1,14 @@
+.PHONY: default build test doc book clean
+
+CARGO_FLAGS := --features "$(FEATURES) alpn"
+
+default: test
+
+build:
+	cargo build $(CARGO_FLAGS)
+
+test: build clippy
+	cargo test $(CARGO_FLAGS)
+
+doc: build
+	cargo doc --no-deps $(CARGO_FLAGS)
--- a/README.md
+++ b/README.md
@@ -1,44 +1,51 @@
-# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![Build status](https://ci.appveyor.com/api/projects/status/kkdb4yce7qhm5w85/branch/master?svg=true)](https://ci.appveyor.com/project/fafhrd91/actix-web-hdy9d/branch/master) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

 Actix web is a simple, pragmatic and extremely fast web framework for Rust.

-* Supported *HTTP/1.x* and *HTTP/2.0* protocols
+* Supported *HTTP/1.x* and [*HTTP/2.0*](https://actix.rs/docs/http2/) protocols
 * Streaming and pipelining
 * Keep-alive and slow requests handling
 * Client/server [WebSockets](https://actix.rs/docs/websockets/) support
 * Transparent content compression/decompression (br, gzip, deflate)
 * Configurable [request routing](https://actix.rs/docs/url-dispatch/)
+* Graceful server shutdown
 * Multipart streams
 * Static assets
-* SSL support with OpenSSL or Rustls
-* Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
+* SSL support with OpenSSL or `native-tls`
+* Middlewares ([Logger](https://actix.rs/book/actix-web/sec-9-middlewares.html#logging),
+  [Session](https://actix.rs/book/actix-web/sec-9-middlewares.html#user-sessions),
+  [Redis sessions](https://github.com/actix/actix-redis),
+  [DefaultHeaders](https://actix.rs/book/actix-web/sec-9-middlewares.html#default-headers),
+  [CORS](https://actix.rs/actix-web/actix_web/middleware/cors/index.html),
+  [CSRF](https://actix.rs/actix-web/actix_web/middleware/csrf/index.html))
 * Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
-* Supports [Actix actor framework](https://github.com/actix/actix)
+* Built on top of [Actix actor framework](https://github.com/actix/actix)

 ## Documentation & community resources

 * [User Guide](https://actix.rs/docs/)
-* [API Documentation (1.0)](https://docs.rs/actix-web/)
-* [API Documentation (0.7)](https://docs.rs/actix-web/0.7.19/actix_web/)
+* [API Documentation (Development)](https://actix.rs/actix-web/actix_web/)
+* [API Documentation (Releases)](https://docs.rs/actix-web/)
 * [Chat on gitter](https://gitter.im/actix/actix)
 * Cargo package: [actix-web](https://crates.io/crates/actix-web)
-* Minimum supported Rust version: 1.36 or later
+* Minimum supported Rust version: 1.24 or later

 ## Example

 ```rust
-use actix_web::{web, App, HttpServer, Responder};
+extern crate actix_web;
+use actix_web::{http, server, App, Path, Responder};

-fn index(info: web::Path<(u32, String)>) -> impl Responder {
+fn index(info: Path<(u32, String)>) -> impl Responder {
    format!("Hello {}! id:{}", info.1, info.0)
 }

-fn main() -> std::io::Result<()> {
-    HttpServer::new(
-        || App::new().service(
-              web::resource("/{id}/{name}/index.html").to(index)))
-        .bind("127.0.0.1:8080")?
-        .run()
+fn main() {
+    server::new(
+        || App::new()
+            .route("/{id}/{name}/index.html", http::Method::GET, index))
+        .bind("127.0.0.1:8080").unwrap()
+        .run();
 }
 ```

@@ -46,9 +53,10 @@ fn main() -> std::io::Result<()> {

 * [Basics](https://github.com/actix/examples/tree/master/basics/)
 * [Stateful](https://github.com/actix/examples/tree/master/state/)
+* [Protobuf support](https://github.com/actix/examples/tree/master/protobuf/)
 * [Multipart streams](https://github.com/actix/examples/tree/master/multipart/)
 * [Simple websocket](https://github.com/actix/examples/tree/master/websocket/)
-* [Tera](https://github.com/actix/examples/tree/master/template_tera/) /
+* [Tera](https://github.com/actix/examples/tree/master/template_tera/) / 
  [Askama](https://github.com/actix/examples/tree/master/template_askama/) templates
 * [Diesel integration](https://github.com/actix/examples/tree/master/diesel/)
 * [r2d2](https://github.com/actix/examples/tree/master/r2d2/)
@@ -61,7 +69,9 @@ You may consider checking out

 ## Benchmarks

-* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r18)
+* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r15&hw=ph&test=plaintext)
+
+* Some basic benchmarks could be found in this [repository](https://github.com/fafhrd91/benchmarks).

 ## License

--- a/actix-cors/CHANGES.md
+++ b/actix-cors/CHANGES.md
@@ -1,9 +0,0 @@
-# Changes
-
-## [0.1.1] - unreleased
-
-* Bump `derive_more` crate version to 0.15.0
-
-## [0.1.0] - 2019-06-15
-
-* Move cors middleware to separate crate
--- a/actix-cors/Cargo.toml
+++ b/actix-cors/Cargo.toml
@@ -1,23 +0,0 @@
-[package]
-name = "actix-cors"
-version = "0.1.0"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Cross-origin resource sharing (CORS) for Actix applications."
-readme = "README.md"
-keywords = ["web", "framework"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-cors/"
-license = "MIT/Apache-2.0"
-edition = "2018"
-#workspace = ".."
-
-[lib]
-name = "actix_cors"
-path = "src/lib.rs"
-
-[dependencies]
-actix-web = "1.0.0"
-actix-service = "0.4.0"
-derive_more = "0.15.0"
-futures = "0.1.25"
--- a/actix-cors/LICENSE-APACHE
+++ b/actix-cors/LICENSE-APACHE
@@ -1 +0,0 @@
-../LICENSE-APACHE
--- a/actix-cors/LICENSE-MIT
+++ b/actix-cors/LICENSE-MIT
@@ -1 +0,0 @@
-../LICENSE-MIT
--- a/actix-cors/README.md
+++ b/actix-cors/README.md
@@ -1,9 +0,0 @@
-# Cors Middleware for actix web framework [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-cors)](https://crates.io/crates/actix-cors) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & community resources
-
-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-cors/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-cors](https://crates.io/crates/actix-cors)
-* Minimum supported Rust version: 1.34 or later
--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@@ -1,64 +0,0 @@
-# Changes
-
-## [0.1.7] - 2019-11-06
-
-* Add an additional `filename*` param in the `Content-Disposition` header of `actix_files::NamedFile` to be more compatible. (#1151)
-
-## [0.1.6] - 2019-10-14
-
-* Add option to redirect to a slash-ended path `Files` #1132
-
-## [0.1.5] - 2019-10-08
-
-* Bump up `mime_guess` crate version to 2.0.1
-
-* Bump up `percent-encoding` crate version to 2.1
-
-* Allow user defined request guards for `Files` #1113
-
-## [0.1.4] - 2019-07-20
-
-* Allow to disable `Content-Disposition` header #686
-
-## [0.1.3] - 2019-06-28
-
-* Do not set `Content-Length` header, let actix-http set it #930
-
-## [0.1.2] - 2019-06-13
-
-* Content-Length is 0 for NamedFile HEAD request #914
-
-* Fix ring dependency from actix-web default features for #741
-
-## [0.1.1] - 2019-06-01
-
-* Static files are incorrectly served as both chunked and with length #812
-
-## [0.1.0] - 2019-05-25
-
-* NamedFile last-modified check always fails due to nano-seconds
-  in file modified date #820
-
-## [0.1.0-beta.4] - 2019-05-12
-
-* Update actix-web to beta.4
-
-## [0.1.0-beta.1] - 2019-04-20
-
-* Update actix-web to beta.1
-
-## [0.1.0-alpha.6] - 2019-04-14
-
-* Update actix-web to alpha6
-
-## [0.1.0-alpha.4] - 2019-04-08
-
-* Update actix-web to alpha4
-
-## [0.1.0-alpha.2] - 2019-04-02
-
-* Add default handler support
-
-## [0.1.0-alpha.1] - 2019-03-28
-
-* Initial impl
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@@ -1,35 +0,0 @@
-[package]
-name = "actix-files"
-version = "0.1.7"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Static files support for actix web."
-readme = "README.md"
-keywords = ["actix", "http", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-files/"
-categories = ["asynchronous", "web-programming::http-server"]
-license = "MIT/Apache-2.0"
-edition = "2018"
-workspace = ".."
-
-[lib]
-name = "actix_files"
-path = "src/lib.rs"
-
-[dependencies]
-actix-web = { version = "1.0.8", default-features = false }
-actix-http = "0.2.11"
-actix-service = "0.4.1"
-bitflags = "1"
-bytes = "0.4"
-futures = "0.1.25"
-derive_more = "0.15.0"
-log = "0.4"
-mime = "0.3"
-mime_guess = "2.0.1"
-percent-encoding = "2.1"
-v_htmlescape = "0.4"
-
-[dev-dependencies]
-actix-web = { version = "1.0.8", features=["ssl"] }
--- a/actix-files/LICENSE-APACHE
+++ b/actix-files/LICENSE-APACHE
@@ -1 +0,0 @@
-../LICENSE-APACHE
--- a/actix-files/LICENSE-MIT
+++ b/actix-files/LICENSE-MIT
@@ -1 +0,0 @@
-../LICENSE-MIT
--- a/actix-files/README.md
+++ b/actix-files/README.md
@@ -1,9 +0,0 @@
-# Static files support for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-files)](https://crates.io/crates/actix-files) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & community resources
-
-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-files/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-files](https://crates.io/crates/actix-files)
-* Minimum supported Rust version: 1.33 or later
--- a/actix-files/src/error.rs
+++ b/actix-files/src/error.rs
@@ -1,41 +0,0 @@
-use actix_web::{http::StatusCode, HttpResponse, ResponseError};
-use derive_more::Display;
-
-/// Errors which can occur when serving static files.
-#[derive(Display, Debug, PartialEq)]
-pub enum FilesError {
-    /// Path is not a directory
-    #[display(fmt = "Path is not a directory. Unable to serve static files")]
-    IsNotDirectory,
-
-    /// Cannot render directory
-    #[display(fmt = "Unable to render directory without index file")]
-    IsDirectory,
-}
-
-/// Return `NotFound` for `FilesError`
-impl ResponseError for FilesError {
-    fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::NOT_FOUND)
-    }
-}
-
-#[derive(Display, Debug, PartialEq)]
-pub enum UriSegmentError {
-    /// The segment started with the wrapped invalid character.
-    #[display(fmt = "The segment started with the wrapped invalid character")]
-    BadStart(char),
-    /// The segment contained the wrapped invalid character.
-    #[display(fmt = "The segment contained the wrapped invalid character")]
-    BadChar(char),
-    /// The segment ended with the wrapped invalid character.
-    #[display(fmt = "The segment ended with the wrapped invalid character")]
-    BadEnd(char),
-}
-
-/// Return `BadRequest` for `UriSegmentError`
-impl ResponseError for UriSegmentError {
-    fn error_response(&self) -> HttpResponse {
-        HttpResponse::new(StatusCode::BAD_REQUEST)
-    }
-}
--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@@ -1,449 +0,0 @@
-use std::fs::{File, Metadata};
-use std::io;
-use std::ops::{Deref, DerefMut};
-use std::path::{Path, PathBuf};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-#[cfg(unix)]
-use std::os::unix::fs::MetadataExt;
-
-use bitflags::bitflags;
-use mime;
-use mime_guess::from_path;
-
-use actix_http::body::SizedStream;
-use actix_web::http::header::{
-    self, Charset, ContentDisposition, DispositionParam, DispositionType, ExtendedValue,
-};
-use actix_web::http::{ContentEncoding, StatusCode};
-use actix_web::middleware::BodyEncoding;
-use actix_web::{Error, HttpMessage, HttpRequest, HttpResponse, Responder};
-
-use crate::range::HttpRange;
-use crate::ChunkedReadFile;
-
-bitflags! {
-    pub(crate) struct Flags: u8 {
-        const ETAG = 0b0000_0001;
-        const LAST_MD = 0b0000_0010;
-        const CONTENT_DISPOSITION = 0b0000_0100;
-    }
-}
-
-impl Default for Flags {
-    fn default() -> Self {
-        Flags::all()
-    }
-}
-
-/// A file with an associated name.
-#[derive(Debug)]
-pub struct NamedFile {
-    path: PathBuf,
-    file: File,
-    modified: Option<SystemTime>,
-    pub(crate) md: Metadata,
-    pub(crate) flags: Flags,
-    pub(crate) status_code: StatusCode,
-    pub(crate) content_type: mime::Mime,
-    pub(crate) content_disposition: header::ContentDisposition,
-    pub(crate) encoding: Option<ContentEncoding>,
-}
-
-impl NamedFile {
-    /// Creates an instance from a previously opened file.
-    ///
-    /// The given `path` need not exist and is only used to determine the `ContentType` and
-    /// `ContentDisposition` headers.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use actix_files::NamedFile;
-    /// use std::io::{self, Write};
-    /// use std::env;
-    /// use std::fs::File;
-    ///
-    /// fn main() -> io::Result<()> {
-    ///     let mut file = File::create("foo.txt")?;
-    ///     file.write_all(b"Hello, world!")?;
-    ///     let named_file = NamedFile::from_file(file, "bar.txt")?;
-    ///     # std::fs::remove_file("foo.txt");
-    ///     Ok(())
-    /// }
-    /// ```
-    pub fn from_file<P: AsRef<Path>>(file: File, path: P) -> io::Result<NamedFile> {
-        let path = path.as_ref().to_path_buf();
-
-        // Get the name of the file and use it to construct default Content-Type
-        // and Content-Disposition values
-        let (content_type, content_disposition) = {
-            let filename = match path.file_name() {
-                Some(name) => name.to_string_lossy(),
-                None => {
-                    return Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        "Provided path has no filename",
-                    ));
-                }
-            };
-
-            let ct = from_path(&path).first_or_octet_stream();
-            let disposition_type = match ct.type_() {
-                mime::IMAGE | mime::TEXT | mime::VIDEO => DispositionType::Inline,
-                _ => DispositionType::Attachment,
-            };
-            let mut parameters =
-                vec![DispositionParam::Filename(String::from(filename.as_ref()))];
-            if !filename.is_ascii() {
-                parameters.push(DispositionParam::FilenameExt(ExtendedValue {
-                    charset: Charset::Ext(String::from("UTF-8")),
-                    language_tag: None,
-                    value: filename.into_owned().into_bytes(),
-                }))
-            }
-            let cd = ContentDisposition {
-                disposition: disposition_type,
-                parameters: parameters,
-            };
-            (ct, cd)
-        };
-
-        let md = file.metadata()?;
-        let modified = md.modified().ok();
-        let encoding = None;
-        Ok(NamedFile {
-            path,
-            file,
-            content_type,
-            content_disposition,
-            md,
-            modified,
-            encoding,
-            status_code: StatusCode::OK,
-            flags: Flags::default(),
-        })
-    }
-
-    /// Attempts to open a file in read-only mode.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use actix_files::NamedFile;
-    ///
-    /// let file = NamedFile::open("foo.txt");
-    /// ```
-    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<NamedFile> {
-        Self::from_file(File::open(&path)?, path)
-    }
-
-    /// Returns reference to the underlying `File` object.
-    #[inline]
-    pub fn file(&self) -> &File {
-        &self.file
-    }
-
-    /// Retrieve the path of this file.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use std::io;
-    /// use actix_files::NamedFile;
-    ///
-    /// # fn path() -> io::Result<()> {
-    /// let file = NamedFile::open("test.txt")?;
-    /// assert_eq!(file.path().as_os_str(), "foo.txt");
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[inline]
-    pub fn path(&self) -> &Path {
-        self.path.as_path()
-    }
-
-    /// Set response **Status Code**
-    pub fn set_status_code(mut self, status: StatusCode) -> Self {
-        self.status_code = status;
-        self
-    }
-
-    /// Set the MIME Content-Type for serving this file. By default
-    /// the Content-Type is inferred from the filename extension.
-    #[inline]
-    pub fn set_content_type(mut self, mime_type: mime::Mime) -> Self {
-        self.content_type = mime_type;
-        self
-    }
-
-    /// Set the Content-Disposition for serving this file. This allows
-    /// changing the inline/attachment disposition as well as the filename
-    /// sent to the peer. By default the disposition is `inline` for text,
-    /// image, and video content types, and `attachment` otherwise, and
-    /// the filename is taken from the path provided in the `open` method
-    /// after converting it to UTF-8 using.
-    /// [to_string_lossy](https://doc.rust-lang.org/std/ffi/struct.OsStr.html#method.to_string_lossy).
-    #[inline]
-    pub fn set_content_disposition(mut self, cd: header::ContentDisposition) -> Self {
-        self.content_disposition = cd;
-        self.flags.insert(Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// Disable `Content-Disposition` header.
-    ///
-    /// By default Content-Disposition` header is enabled.
-    #[inline]
-    pub fn disable_content_disposition(mut self) -> Self {
-        self.flags.remove(Flags::CONTENT_DISPOSITION);
-        self
-    }
-
-    /// Set content encoding for serving this file
-    #[inline]
-    pub fn set_content_encoding(mut self, enc: ContentEncoding) -> Self {
-        self.encoding = Some(enc);
-        self
-    }
-
-    #[inline]
-    ///Specifies whether to use ETag or not.
-    ///
-    ///Default is true.
-    pub fn use_etag(mut self, value: bool) -> Self {
-        self.flags.set(Flags::ETAG, value);
-        self
-    }
-
-    #[inline]
-    ///Specifies whether to use Last-Modified or not.
-    ///
-    ///Default is true.
-    pub fn use_last_modified(mut self, value: bool) -> Self {
-        self.flags.set(Flags::LAST_MD, value);
-        self
-    }
-
-    pub(crate) fn etag(&self) -> Option<header::EntityTag> {
-        // This etag format is similar to Apache's.
-        self.modified.as_ref().map(|mtime| {
-            let ino = {
-                #[cfg(unix)]
-                {
-                    self.md.ino()
-                }
-                #[cfg(not(unix))]
-                {
-                    0
-                }
-            };
-
-            let dur = mtime
-                .duration_since(UNIX_EPOCH)
-                .expect("modification time must be after epoch");
-            header::EntityTag::strong(format!(
-                "{:x}:{:x}:{:x}:{:x}",
-                ino,
-                self.md.len(),
-                dur.as_secs(),
-                dur.subsec_nanos()
-            ))
-        })
-    }
-
-    pub(crate) fn last_modified(&self) -> Option<header::HttpDate> {
-        self.modified.map(|mtime| mtime.into())
-    }
-}
-
-impl Deref for NamedFile {
-    type Target = File;
-
-    fn deref(&self) -> &File {
-        &self.file
-    }
-}
-
-impl DerefMut for NamedFile {
-    fn deref_mut(&mut self) -> &mut File {
-        &mut self.file
-    }
-}
-
-/// Returns true if `req` has no `If-Match` header or one which matches `etag`.
-fn any_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
-    match req.get_header::<header::IfMatch>() {
-        None | Some(header::IfMatch::Any) => true,
-        Some(header::IfMatch::Items(ref items)) => {
-            if let Some(some_etag) = etag {
-                for item in items {
-                    if item.strong_eq(some_etag) {
-                        return true;
-                    }
-                }
-            }
-            false
-        }
-    }
-}
-
-/// Returns true if `req` doesn't have an `If-None-Match` header matching `req`.
-fn none_match(etag: Option<&header::EntityTag>, req: &HttpRequest) -> bool {
-    match req.get_header::<header::IfNoneMatch>() {
-        Some(header::IfNoneMatch::Any) => false,
-        Some(header::IfNoneMatch::Items(ref items)) => {
-            if let Some(some_etag) = etag {
-                for item in items {
-                    if item.weak_eq(some_etag) {
-                        return false;
-                    }
-                }
-            }
-            true
-        }
-        None => true,
-    }
-}
-
-impl Responder for NamedFile {
-    type Error = Error;
-    type Future = Result<HttpResponse, Error>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
-        if self.status_code != StatusCode::OK {
-            let mut resp = HttpResponse::build(self.status_code);
-            resp.set(header::ContentType(self.content_type.clone()))
-                .if_true(self.flags.contains(Flags::CONTENT_DISPOSITION), |res| {
-                    res.header(
-                        header::CONTENT_DISPOSITION,
-                        self.content_disposition.to_string(),
-                    );
-                });
-            if let Some(current_encoding) = self.encoding {
-                resp.encoding(current_encoding);
-            }
-            let reader = ChunkedReadFile {
-                size: self.md.len(),
-                offset: 0,
-                file: Some(self.file),
-                fut: None,
-                counter: 0,
-            };
-            return Ok(resp.streaming(reader));
-        }
-
-        let etag = if self.flags.contains(Flags::ETAG) {
-            self.etag()
-        } else {
-            None
-        };
-        let last_modified = if self.flags.contains(Flags::LAST_MD) {
-            self.last_modified()
-        } else {
-            None
-        };
-
-        // check preconditions
-        let precondition_failed = if !any_match(etag.as_ref(), req) {
-            true
-        } else if let (Some(ref m), Some(header::IfUnmodifiedSince(ref since))) =
-            (last_modified, req.get_header())
-        {
-            let t1: SystemTime = m.clone().into();
-            let t2: SystemTime = since.clone().into();
-            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1 > t2,
-                _ => false,
-            }
-        } else {
-            false
-        };
-
-        // check last modified
-        let not_modified = if !none_match(etag.as_ref(), req) {
-            true
-        } else if req.headers().contains_key(&header::IF_NONE_MATCH) {
-            false
-        } else if let (Some(ref m), Some(header::IfModifiedSince(ref since))) =
-            (last_modified, req.get_header())
-        {
-            let t1: SystemTime = m.clone().into();
-            let t2: SystemTime = since.clone().into();
-            match (t1.duration_since(UNIX_EPOCH), t2.duration_since(UNIX_EPOCH)) {
-                (Ok(t1), Ok(t2)) => t1 <= t2,
-                _ => false,
-            }
-        } else {
-            false
-        };
-
-        let mut resp = HttpResponse::build(self.status_code);
-        resp.set(header::ContentType(self.content_type.clone()))
-            .if_true(self.flags.contains(Flags::CONTENT_DISPOSITION), |res| {
-                res.header(
-                    header::CONTENT_DISPOSITION,
-                    self.content_disposition.to_string(),
-                );
-            });
-        // default compressing
-        if let Some(current_encoding) = self.encoding {
-            resp.encoding(current_encoding);
-        }
-
-        resp.if_some(last_modified, |lm, resp| {
-            resp.set(header::LastModified(lm));
-        })
-        .if_some(etag, |etag, resp| {
-            resp.set(header::ETag(etag));
-        });
-
-        resp.header(header::ACCEPT_RANGES, "bytes");
-
-        let mut length = self.md.len();
-        let mut offset = 0;
-
-        // check for range header
-        if let Some(ranges) = req.headers().get(&header::RANGE) {
-            if let Ok(rangesheader) = ranges.to_str() {
-                if let Ok(rangesvec) = HttpRange::parse(rangesheader, length) {
-                    length = rangesvec[0].length;
-                    offset = rangesvec[0].start;
-                    resp.encoding(ContentEncoding::Identity);
-                    resp.header(
-                        header::CONTENT_RANGE,
-                        format!(
-                            "bytes {}-{}/{}",
-                            offset,
-                            offset + length - 1,
-                            self.md.len()
-                        ),
-                    );
-                } else {
-                    resp.header(header::CONTENT_RANGE, format!("bytes */{}", length));
-                    return Ok(resp.status(StatusCode::RANGE_NOT_SATISFIABLE).finish());
-                };
-            } else {
-                return Ok(resp.status(StatusCode::BAD_REQUEST).finish());
-            };
-        };
-
-        if precondition_failed {
-            return Ok(resp.status(StatusCode::PRECONDITION_FAILED).finish());
-        } else if not_modified {
-            return Ok(resp.status(StatusCode::NOT_MODIFIED).finish());
-        }
-
-        let reader = ChunkedReadFile {
-            offset,
-            size: length,
-            file: Some(self.file),
-            fut: None,
-            counter: 0,
-        };
-        if offset != 0 || length != self.md.len() {
-            return Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader));
-        };
-        Ok(resp.body(SizedStream::new(length, reader)))
-    }
-}
--- a/actix-files/src/range.rs
+++ b/actix-files/src/range.rs
@@ -1,375 +0,0 @@
-/// HTTP Range header representation.
-#[derive(Debug, Clone, Copy)]
-pub struct HttpRange {
-    pub start: u64,
-    pub length: u64,
-}
-
-static PREFIX: &str = "bytes=";
-const PREFIX_LEN: usize = 6;
-
-impl HttpRange {
-    /// Parses Range HTTP header string as per RFC 2616.
-    ///
-    /// `header` is HTTP Range header (e.g. `bytes=bytes=0-9`).
-    /// `size` is full size of response (file).
-    pub fn parse(header: &str, size: u64) -> Result<Vec<HttpRange>, ()> {
-        if header.is_empty() {
-            return Ok(Vec::new());
-        }
-        if !header.starts_with(PREFIX) {
-            return Err(());
-        }
-
-        let size_sig = size as i64;
-        let mut no_overlap = false;
-
-        let all_ranges: Vec<Option<HttpRange>> = header[PREFIX_LEN..]
-            .split(',')
-            .map(|x| x.trim())
-            .filter(|x| !x.is_empty())
-            .map(|ra| {
-                let mut start_end_iter = ra.split('-');
-
-                let start_str = start_end_iter.next().ok_or(())?.trim();
-                let end_str = start_end_iter.next().ok_or(())?.trim();
-
-                if start_str.is_empty() {
-                    // If no start is specified, end specifies the
-                    // range start relative to the end of the file.
-                    let mut length: i64 = end_str.parse().map_err(|_| ())?;
-
-                    if length > size_sig {
-                        length = size_sig;
-                    }
-
-                    Ok(Some(HttpRange {
-                        start: (size_sig - length) as u64,
-                        length: length as u64,
-                    }))
-                } else {
-                    let start: i64 = start_str.parse().map_err(|_| ())?;
-
-                    if start < 0 {
-                        return Err(());
-                    }
-                    if start >= size_sig {
-                        no_overlap = true;
-                        return Ok(None);
-                    }
-
-                    let length = if end_str.is_empty() {
-                        // If no end is specified, range extends to end of the file.
-                        size_sig - start
-                    } else {
-                        let mut end: i64 = end_str.parse().map_err(|_| ())?;
-
-                        if start > end {
-                            return Err(());
-                        }
-
-                        if end >= size_sig {
-                            end = size_sig - 1;
-                        }
-
-                        end - start + 1
-                    };
-
-                    Ok(Some(HttpRange {
-                        start: start as u64,
-                        length: length as u64,
-                    }))
-                }
-            })
-            .collect::<Result<_, _>>()?;
-
-        let ranges: Vec<HttpRange> = all_ranges.into_iter().filter_map(|x| x).collect();
-
-        if no_overlap && ranges.is_empty() {
-            return Err(());
-        }
-
-        Ok(ranges)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    struct T(&'static str, u64, Vec<HttpRange>);
-
-    #[test]
-    fn test_parse() {
-        let tests = vec![
-            T("", 0, vec![]),
-            T("", 1000, vec![]),
-            T("foo", 0, vec![]),
-            T("bytes=", 0, vec![]),
-            T("bytes=7", 10, vec![]),
-            T("bytes= 7 ", 10, vec![]),
-            T("bytes=1-", 0, vec![]),
-            T("bytes=5-4", 10, vec![]),
-            T("bytes=0-2,5-4", 10, vec![]),
-            T("bytes=2-5,4-3", 10, vec![]),
-            T("bytes=--5,4--3", 10, vec![]),
-            T("bytes=A-", 10, vec![]),
-            T("bytes=A- ", 10, vec![]),
-            T("bytes=A-Z", 10, vec![]),
-            T("bytes= -Z", 10, vec![]),
-            T("bytes=5-Z", 10, vec![]),
-            T("bytes=Ran-dom, garbage", 10, vec![]),
-            T("bytes=0x01-0x02", 10, vec![]),
-            T("bytes=         ", 10, vec![]),
-            T("bytes= , , ,   ", 10, vec![]),
-            T(
-                "bytes=0-9",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=0-",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=5-",
-                10,
-                vec![HttpRange {
-                    start: 5,
-                    length: 5,
-                }],
-            ),
-            T(
-                "bytes=0-20",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=15-,0-5",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 6,
-                }],
-            ),
-            T(
-                "bytes=1-2,5-",
-                10,
-                vec![
-                    HttpRange {
-                        start: 1,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 5,
-                        length: 5,
-                    },
-                ],
-            ),
-            T(
-                "bytes=-2 , 7-",
-                11,
-                vec![
-                    HttpRange {
-                        start: 9,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 7,
-                        length: 4,
-                    },
-                ],
-            ),
-            T(
-                "bytes=0-0 ,2-2, 7-",
-                11,
-                vec![
-                    HttpRange {
-                        start: 0,
-                        length: 1,
-                    },
-                    HttpRange {
-                        start: 2,
-                        length: 1,
-                    },
-                    HttpRange {
-                        start: 7,
-                        length: 4,
-                    },
-                ],
-            ),
-            T(
-                "bytes=-5",
-                10,
-                vec![HttpRange {
-                    start: 5,
-                    length: 5,
-                }],
-            ),
-            T(
-                "bytes=-15",
-                10,
-                vec![HttpRange {
-                    start: 0,
-                    length: 10,
-                }],
-            ),
-            T(
-                "bytes=0-499",
-                10000,
-                vec![HttpRange {
-                    start: 0,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=500-999",
-                10000,
-                vec![HttpRange {
-                    start: 500,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=-500",
-                10000,
-                vec![HttpRange {
-                    start: 9500,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=9500-",
-                10000,
-                vec![HttpRange {
-                    start: 9500,
-                    length: 500,
-                }],
-            ),
-            T(
-                "bytes=0-0,-1",
-                10000,
-                vec![
-                    HttpRange {
-                        start: 0,
-                        length: 1,
-                    },
-                    HttpRange {
-                        start: 9999,
-                        length: 1,
-                    },
-                ],
-            ),
-            T(
-                "bytes=500-600,601-999",
-                10000,
-                vec![
-                    HttpRange {
-                        start: 500,
-                        length: 101,
-                    },
-                    HttpRange {
-                        start: 601,
-                        length: 399,
-                    },
-                ],
-            ),
-            T(
-                "bytes=500-700,601-999",
-                10000,
-                vec![
-                    HttpRange {
-                        start: 500,
-                        length: 201,
-                    },
-                    HttpRange {
-                        start: 601,
-                        length: 399,
-                    },
-                ],
-            ),
-            // Match Apache laxity:
-            T(
-                "bytes=   1 -2   ,  4- 5, 7 - 8 , ,,",
-                11,
-                vec![
-                    HttpRange {
-                        start: 1,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 4,
-                        length: 2,
-                    },
-                    HttpRange {
-                        start: 7,
-                        length: 2,
-                    },
-                ],
-            ),
-        ];
-
-        for t in tests {
-            let header = t.0;
-            let size = t.1;
-            let expected = t.2;
-
-            let res = HttpRange::parse(header, size);
-
-            if res.is_err() {
-                if expected.is_empty() {
-                    continue;
-                } else {
-                    assert!(
-                        false,
-                        "parse({}, {}) returned error {:?}",
-                        header,
-                        size,
-                        res.unwrap_err()
-                    );
-                }
-            }
-
-            let got = res.unwrap();
-
-            if got.len() != expected.len() {
-                assert!(
-                    false,
-                    "len(parseRange({}, {})) = {}, want {}",
-                    header,
-                    size,
-                    got.len(),
-                    expected.len()
-                );
-                continue;
-            }
-
-            for i in 0..expected.len() {
-                if got[i].start != expected[i].start {
-                    assert!(
-                        false,
-                        "parseRange({}, {})[{}].start = {}, want {}",
-                        header, size, i, got[i].start, expected[i].start
-                    )
-                }
-                if got[i].length != expected[i].length {
-                    assert!(
-                        false,
-                        "parseRange({}, {})[{}].length = {}, want {}",
-                        header, size, i, got[i].length, expected[i].length
-                    )
-                }
-            }
-        }
-    }
-}
--- a/actix-files/tests/test
+++ b/actix-files/tests/test
@@ -1 +0,0 @@
-<EFBFBD>TǑɂV<EFBFBD>2<EFBFBD>vI<EFBFBD><EFBFBD><EFBFBD>\<5C>R˙<52><CB99><EFBFBD>e<EFBFBD><04>vD<76>:藽<>RV<03>Yp<59><70>;<3B><>G<><47>p!2<7F>C<EFBFBD>.<2E><0C><><EFBFBD><EFBFBD>pA!<21>ߦ<EFBFBD>x	j+Uc<55><63><EFBFBD>X<13>c%<17>;<3B>"y<10><>AI
--- a/actix-framed/Cargo.toml
+++ b/actix-framed/Cargo.toml
@@ -1,38 +0,0 @@
-[package]
-name = "actix-framed"
-version = "0.2.1"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix framed app server"
-readme = "README.md"
-keywords = ["http", "web", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-framed/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
-license = "MIT/Apache-2.0"
-edition = "2018"
-workspace =".."
-
-[lib]
-name = "actix_framed"
-path = "src/lib.rs"
-
-[dependencies]
-actix-codec = "0.1.2"
-actix-service = "0.4.1"
-actix-router = "0.1.2"
-actix-rt = "0.2.2"
-actix-http = "0.2.7"
-actix-server-config = "0.1.2"
-
-bytes = "0.4"
-futures = "0.1.25"
-log = "0.4"
-
-[dev-dependencies]
-actix-server = { version = "0.6.0", features=["ssl"] }
-actix-connect = { version = "0.2.0", features=["ssl"] }
-actix-http-test = { version = "0.2.4", features=["ssl"] }
-actix-utils = "0.4.4"
--- a/actix-framed/LICENSE-APACHE
+++ b/actix-framed/LICENSE-APACHE
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2017-NOW Nikolay Kim
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--- a/actix-framed/LICENSE-MIT
+++ b/actix-framed/LICENSE-MIT
@@ -1,25 +0,0 @@
-Copyright (c) 2017 Nikolay Kim
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
--- a/actix-framed/README.md
+++ b/actix-framed/README.md
@@ -1,8 +0,0 @@
-# Framed app for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-framed)](https://crates.io/crates/actix-framed) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-## Documentation & community resources
-
-* [API Documentation](https://docs.rs/actix-framed/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-framed](https://crates.io/crates/actix-framed)
-* Minimum supported Rust version: 1.33 or later
--- a/actix-framed/changes.md
+++ b/actix-framed/changes.md
@@ -1,20 +0,0 @@
-# Changes
-
-## [0.2.1] - 2019-07-20
-
-* Remove unneeded actix-utils dependency
-
-
-## [0.2.0] - 2019-05-12
-
-* Update dependencies
-
-
-## [0.1.0] - 2019-04-16
-
-* Update tests
-
-
-## [0.1.0-alpha.1] - 2019-04-12
-
-* Initial release
--- a/actix-framed/src/app.rs
+++ b/actix-framed/src/app.rs
@@ -1,217 +0,0 @@
-use std::rc::Rc;
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_http::h1::{Codec, SendResponse};
-use actix_http::{Error, Request, Response};
-use actix_router::{Path, Router, Url};
-use actix_server_config::ServerConfig;
-use actix_service::{IntoNewService, NewService, Service};
-use futures::{Async, Future, Poll};
-
-use crate::helpers::{BoxedHttpNewService, BoxedHttpService, HttpNewService};
-use crate::request::FramedRequest;
-use crate::state::State;
-
-type BoxedResponse = Box<dyn Future<Item = (), Error = Error>>;
-
-pub trait HttpServiceFactory {
-    type Factory: NewService;
-
-    fn path(&self) -> &str;
-
-    fn create(self) -> Self::Factory;
-}
-
-/// Application builder
-pub struct FramedApp<T, S = ()> {
-    state: State<S>,
-    services: Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>,
-}
-
-impl<T: 'static> FramedApp<T, ()> {
-    pub fn new() -> Self {
-        FramedApp {
-            state: State::new(()),
-            services: Vec::new(),
-        }
-    }
-}
-
-impl<T: 'static, S: 'static> FramedApp<T, S> {
-    pub fn with(state: S) -> FramedApp<T, S> {
-        FramedApp {
-            services: Vec::new(),
-            state: State::new(state),
-        }
-    }
-
-    pub fn service<U>(mut self, factory: U) -> Self
-    where
-        U: HttpServiceFactory,
-        U::Factory: NewService<
-                Config = (),
-                Request = FramedRequest<T, S>,
-                Response = (),
-                Error = Error,
-                InitError = (),
-            > + 'static,
-        <U::Factory as NewService>::Future: 'static,
-        <U::Factory as NewService>::Service: Service<
-            Request = FramedRequest<T, S>,
-            Response = (),
-            Error = Error,
-            Future = Box<dyn Future<Item = (), Error = Error>>,
-        >,
-    {
-        let path = factory.path().to_string();
-        self.services
-            .push((path, Box::new(HttpNewService::new(factory.create()))));
-        self
-    }
-}
-
-impl<T, S> IntoNewService<FramedAppFactory<T, S>> for FramedApp<T, S>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    S: 'static,
-{
-    fn into_new_service(self) -> FramedAppFactory<T, S> {
-        FramedAppFactory {
-            state: self.state,
-            services: Rc::new(self.services),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct FramedAppFactory<T, S> {
-    state: State<S>,
-    services: Rc<Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>>,
-}
-
-impl<T, S> NewService for FramedAppFactory<T, S>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    S: 'static,
-{
-    type Config = ServerConfig;
-    type Request = (Request, Framed<T, Codec>);
-    type Response = ();
-    type Error = Error;
-    type InitError = ();
-    type Service = FramedAppService<T, S>;
-    type Future = CreateService<T, S>;
-
-    fn new_service(&self, _: &ServerConfig) -> Self::Future {
-        CreateService {
-            fut: self
-                .services
-                .iter()
-                .map(|(path, service)| {
-                    CreateServiceItem::Future(
-                        Some(path.clone()),
-                        service.new_service(&()),
-                    )
-                })
-                .collect(),
-            state: self.state.clone(),
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct CreateService<T, S> {
-    fut: Vec<CreateServiceItem<T, S>>,
-    state: State<S>,
-}
-
-enum CreateServiceItem<T, S> {
-    Future(
-        Option<String>,
-        Box<dyn Future<Item = BoxedHttpService<FramedRequest<T, S>>, Error = ()>>,
-    ),
-    Service(String, BoxedHttpService<FramedRequest<T, S>>),
-}
-
-impl<S: 'static, T: 'static> Future for CreateService<T, S>
-where
-    T: AsyncRead + AsyncWrite,
-{
-    type Item = FramedAppService<T, S>;
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let mut done = true;
-
-        // poll http services
-        for item in &mut self.fut {
-            let res = match item {
-                CreateServiceItem::Future(ref mut path, ref mut fut) => {
-                    match fut.poll()? {
-                        Async::Ready(service) => Some((path.take().unwrap(), service)),
-                        Async::NotReady => {
-                            done = false;
-                            None
-                        }
-                    }
-                }
-                CreateServiceItem::Service(_, _) => continue,
-            };
-
-            if let Some((path, service)) = res {
-                *item = CreateServiceItem::Service(path, service);
-            }
-        }
-
-        if done {
-            let router = self
-                .fut
-                .drain(..)
-                .fold(Router::build(), |mut router, item| {
-                    match item {
-                        CreateServiceItem::Service(path, service) => {
-                            router.path(&path, service);
-                        }
-                        CreateServiceItem::Future(_, _) => unreachable!(),
-                    }
-                    router
-                });
-            Ok(Async::Ready(FramedAppService {
-                router: router.finish(),
-                state: self.state.clone(),
-            }))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-}
-
-pub struct FramedAppService<T, S> {
-    state: State<S>,
-    router: Router<BoxedHttpService<FramedRequest<T, S>>>,
-}
-
-impl<S: 'static, T: 'static> Service for FramedAppService<T, S>
-where
-    T: AsyncRead + AsyncWrite,
-{
-    type Request = (Request, Framed<T, Codec>);
-    type Response = ();
-    type Error = Error;
-    type Future = BoxedResponse;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
-        let mut path = Path::new(Url::new(req.uri().clone()));
-
-        if let Some((srv, _info)) = self.router.recognize_mut(&mut path) {
-            return srv.call(FramedRequest::new(req, framed, path, self.state.clone()));
-        }
-        Box::new(
-            SendResponse::new(framed, Response::NotFound().finish()).then(|_| Ok(())),
-        )
-    }
-}
--- a/actix-framed/src/helpers.rs
+++ b/actix-framed/src/helpers.rs
@@ -1,90 +0,0 @@
-use actix_http::Error;
-use actix_service::{NewService, Service};
-use futures::{Future, Poll};
-
-pub(crate) type BoxedHttpService<Req> = Box<
-    dyn Service<
-        Request = Req,
-        Response = (),
-        Error = Error,
-        Future = Box<dyn Future<Item = (), Error = Error>>,
-    >,
->;
-
-pub(crate) type BoxedHttpNewService<Req> = Box<
-    dyn NewService<
-        Config = (),
-        Request = Req,
-        Response = (),
-        Error = Error,
-        InitError = (),
-        Service = BoxedHttpService<Req>,
-        Future = Box<dyn Future<Item = BoxedHttpService<Req>, Error = ()>>,
-    >,
->;
-
-pub(crate) struct HttpNewService<T: NewService>(T);
-
-impl<T> HttpNewService<T>
-where
-    T: NewService<Response = (), Error = Error>,
-    T::Response: 'static,
-    T::Future: 'static,
-    T::Service: Service<Future = Box<dyn Future<Item = (), Error = Error>>> + 'static,
-    <T::Service as Service>::Future: 'static,
-{
-    pub fn new(service: T) -> Self {
-        HttpNewService(service)
-    }
-}
-
-impl<T> NewService for HttpNewService<T>
-where
-    T: NewService<Config = (), Response = (), Error = Error>,
-    T::Request: 'static,
-    T::Future: 'static,
-    T::Service: Service<Future = Box<dyn Future<Item = (), Error = Error>>> + 'static,
-    <T::Service as Service>::Future: 'static,
-{
-    type Config = ();
-    type Request = T::Request;
-    type Response = ();
-    type Error = Error;
-    type InitError = ();
-    type Service = BoxedHttpService<T::Request>;
-    type Future = Box<dyn Future<Item = Self::Service, Error = ()>>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        Box::new(self.0.new_service(&()).map_err(|_| ()).and_then(|service| {
-            let service: BoxedHttpService<_> = Box::new(HttpServiceWrapper { service });
-            Ok(service)
-        }))
-    }
-}
-
-struct HttpServiceWrapper<T: Service> {
-    service: T,
-}
-
-impl<T> Service for HttpServiceWrapper<T>
-where
-    T: Service<
-        Response = (),
-        Future = Box<dyn Future<Item = (), Error = Error>>,
-        Error = Error,
-    >,
-    T::Request: 'static,
-{
-    type Request = T::Request;
-    type Response = ();
-    type Error = Error;
-    type Future = Box<dyn Future<Item = (), Error = Error>>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.service.poll_ready()
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        self.service.call(req)
-    }
-}
--- a/actix-framed/src/lib.rs
+++ b/actix-framed/src/lib.rs
@@ -1,17 +0,0 @@
-#![allow(clippy::type_complexity, clippy::new_without_default, dead_code)]
-mod app;
-mod helpers;
-mod request;
-mod route;
-mod service;
-mod state;
-pub mod test;
-
-// re-export for convinience
-pub use actix_http::{http, Error, HttpMessage, Response, ResponseError};
-
-pub use self::app::{FramedApp, FramedAppService};
-pub use self::request::FramedRequest;
-pub use self::route::FramedRoute;
-pub use self::service::{SendError, VerifyWebSockets};
-pub use self::state::State;
--- a/actix-framed/src/request.rs
+++ b/actix-framed/src/request.rs
@@ -1,170 +0,0 @@
-use std::cell::{Ref, RefMut};
-
-use actix_codec::Framed;
-use actix_http::http::{HeaderMap, Method, Uri, Version};
-use actix_http::{h1::Codec, Extensions, Request, RequestHead};
-use actix_router::{Path, Url};
-
-use crate::state::State;
-
-pub struct FramedRequest<Io, S = ()> {
-    req: Request,
-    framed: Framed<Io, Codec>,
-    state: State<S>,
-    pub(crate) path: Path<Url>,
-}
-
-impl<Io, S> FramedRequest<Io, S> {
-    pub fn new(
-        req: Request,
-        framed: Framed<Io, Codec>,
-        path: Path<Url>,
-        state: State<S>,
-    ) -> Self {
-        Self {
-            req,
-            framed,
-            state,
-            path,
-        }
-    }
-}
-
-impl<Io, S> FramedRequest<Io, S> {
-    /// Split request into a parts
-    pub fn into_parts(self) -> (Request, Framed<Io, Codec>, State<S>) {
-        (self.req, self.framed, self.state)
-    }
-
-    /// This method returns reference to the request head
-    #[inline]
-    pub fn head(&self) -> &RequestHead {
-        self.req.head()
-    }
-
-    /// This method returns muttable reference to the request head.
-    /// panics if multiple references of http request exists.
-    #[inline]
-    pub fn head_mut(&mut self) -> &mut RequestHead {
-        self.req.head_mut()
-    }
-
-    /// Shared application state
-    #[inline]
-    pub fn state(&self) -> &S {
-        self.state.get_ref()
-    }
-
-    /// Request's uri.
-    #[inline]
-    pub fn uri(&self) -> &Uri {
-        &self.head().uri
-    }
-
-    /// Read the Request method.
-    #[inline]
-    pub fn method(&self) -> &Method {
-        &self.head().method
-    }
-
-    /// Read the Request Version.
-    #[inline]
-    pub fn version(&self) -> Version {
-        self.head().version
-    }
-
-    #[inline]
-    /// Returns request's headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    /// The target path of this Request.
-    #[inline]
-    pub fn path(&self) -> &str {
-        self.head().uri.path()
-    }
-
-    /// The query string in the URL.
-    ///
-    /// E.g., id=10
-    #[inline]
-    pub fn query_string(&self) -> &str {
-        if let Some(query) = self.uri().query().as_ref() {
-            query
-        } else {
-            ""
-        }
-    }
-
-    /// Get a reference to the Path parameters.
-    ///
-    /// Params is a container for url parameters.
-    /// A variable segment is specified in the form `{identifier}`,
-    /// where the identifier can be used later in a request handler to
-    /// access the matched value for that segment.
-    #[inline]
-    pub fn match_info(&self) -> &Path<Url> {
-        &self.path
-    }
-
-    /// Request extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<Extensions> {
-        self.head().extensions()
-    }
-
-    /// Mutable reference to a the request's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<Extensions> {
-        self.head().extensions_mut()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use actix_http::http::{HeaderName, HeaderValue, HttpTryFrom};
-    use actix_http::test::{TestBuffer, TestRequest};
-
-    use super::*;
-
-    #[test]
-    fn test_reqest() {
-        let buf = TestBuffer::empty();
-        let framed = Framed::new(buf, Codec::default());
-        let req = TestRequest::with_uri("/index.html?q=1")
-            .header("content-type", "test")
-            .finish();
-        let path = Path::new(Url::new(req.uri().clone()));
-
-        let mut freq = FramedRequest::new(req, framed, path, State::new(10u8));
-        assert_eq!(*freq.state(), 10);
-        assert_eq!(freq.version(), Version::HTTP_11);
-        assert_eq!(freq.method(), Method::GET);
-        assert_eq!(freq.path(), "/index.html");
-        assert_eq!(freq.query_string(), "q=1");
-        assert_eq!(
-            freq.headers()
-                .get("content-type")
-                .unwrap()
-                .to_str()
-                .unwrap(),
-            "test"
-        );
-
-        freq.head_mut().headers.insert(
-            HeaderName::try_from("x-hdr").unwrap(),
-            HeaderValue::from_static("test"),
-        );
-        assert_eq!(
-            freq.headers().get("x-hdr").unwrap().to_str().unwrap(),
-            "test"
-        );
-
-        freq.extensions_mut().insert(100usize);
-        assert_eq!(*freq.extensions().get::<usize>().unwrap(), 100usize);
-
-        let (_, _, state) = freq.into_parts();
-        assert_eq!(*state, 10);
-    }
-}
--- a/actix-framed/src/route.rs
+++ b/actix-framed/src/route.rs
@@ -1,157 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_http::{http::Method, Error};
-use actix_service::{NewService, Service};
-use futures::future::{ok, FutureResult};
-use futures::{Async, Future, IntoFuture, Poll};
-use log::error;
-
-use crate::app::HttpServiceFactory;
-use crate::request::FramedRequest;
-
-/// Resource route definition
-///
-/// Route uses builder-like pattern for configuration.
-/// If handler is not explicitly set, default *404 Not Found* handler is used.
-pub struct FramedRoute<Io, S, F = (), R = ()> {
-    handler: F,
-    pattern: String,
-    methods: Vec<Method>,
-    state: PhantomData<(Io, S, R)>,
-}
-
-impl<Io, S> FramedRoute<Io, S> {
-    pub fn new(pattern: &str) -> Self {
-        FramedRoute {
-            handler: (),
-            pattern: pattern.to_string(),
-            methods: Vec::new(),
-            state: PhantomData,
-        }
-    }
-
-    pub fn get(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::GET)
-    }
-
-    pub fn post(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::POST)
-    }
-
-    pub fn put(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::PUT)
-    }
-
-    pub fn delete(path: &str) -> FramedRoute<Io, S> {
-        FramedRoute::new(path).method(Method::DELETE)
-    }
-
-    pub fn method(mut self, method: Method) -> Self {
-        self.methods.push(method);
-        self
-    }
-
-    pub fn to<F, R>(self, handler: F) -> FramedRoute<Io, S, F, R>
-    where
-        F: FnMut(FramedRequest<Io, S>) -> R,
-        R: IntoFuture<Item = ()>,
-        R::Future: 'static,
-        R::Error: fmt::Debug,
-    {
-        FramedRoute {
-            handler,
-            pattern: self.pattern,
-            methods: self.methods,
-            state: PhantomData,
-        }
-    }
-}
-
-impl<Io, S, F, R> HttpServiceFactory for FramedRoute<Io, S, F, R>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
-    R: IntoFuture<Item = ()>,
-    R::Future: 'static,
-    R::Error: fmt::Display,
-{
-    type Factory = FramedRouteFactory<Io, S, F, R>;
-
-    fn path(&self) -> &str {
-        &self.pattern
-    }
-
-    fn create(self) -> Self::Factory {
-        FramedRouteFactory {
-            handler: self.handler,
-            methods: self.methods,
-            _t: PhantomData,
-        }
-    }
-}
-
-pub struct FramedRouteFactory<Io, S, F, R> {
-    handler: F,
-    methods: Vec<Method>,
-    _t: PhantomData<(Io, S, R)>,
-}
-
-impl<Io, S, F, R> NewService for FramedRouteFactory<Io, S, F, R>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
-    R: IntoFuture<Item = ()>,
-    R::Future: 'static,
-    R::Error: fmt::Display,
-{
-    type Config = ();
-    type Request = FramedRequest<Io, S>;
-    type Response = ();
-    type Error = Error;
-    type InitError = ();
-    type Service = FramedRouteService<Io, S, F, R>;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &()) -> Self::Future {
-        ok(FramedRouteService {
-            handler: self.handler.clone(),
-            methods: self.methods.clone(),
-            _t: PhantomData,
-        })
-    }
-}
-
-pub struct FramedRouteService<Io, S, F, R> {
-    handler: F,
-    methods: Vec<Method>,
-    _t: PhantomData<(Io, S, R)>,
-}
-
-impl<Io, S, F, R> Service for FramedRouteService<Io, S, F, R>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
-    R: IntoFuture<Item = ()>,
-    R::Future: 'static,
-    R::Error: fmt::Display,
-{
-    type Request = FramedRequest<Io, S>;
-    type Response = ();
-    type Error = Error;
-    type Future = Box<dyn Future<Item = (), Error = Error>>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: FramedRequest<Io, S>) -> Self::Future {
-        Box::new((self.handler)(req).into_future().then(|res| {
-            if let Err(e) = res {
-                error!("Error in request handler: {}", e);
-            }
-            Ok(())
-        }))
-    }
-}
--- a/actix-framed/src/service.rs
+++ b/actix-framed/src/service.rs
@@ -1,149 +0,0 @@
-use std::marker::PhantomData;
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_http::body::BodySize;
-use actix_http::error::ResponseError;
-use actix_http::h1::{Codec, Message};
-use actix_http::ws::{verify_handshake, HandshakeError};
-use actix_http::{Request, Response};
-use actix_service::{NewService, Service};
-use futures::future::{ok, Either, FutureResult};
-use futures::{Async, Future, IntoFuture, Poll, Sink};
-
-/// Service that verifies incoming request if it is valid websocket
-/// upgrade request. In case of error returns `HandshakeError`
-pub struct VerifyWebSockets<T, C> {
-    _t: PhantomData<(T, C)>,
-}
-
-impl<T, C> Default for VerifyWebSockets<T, C> {
-    fn default() -> Self {
-        VerifyWebSockets { _t: PhantomData }
-    }
-}
-
-impl<T, C> NewService for VerifyWebSockets<T, C> {
-    type Config = C;
-    type Request = (Request, Framed<T, Codec>);
-    type Response = (Request, Framed<T, Codec>);
-    type Error = (HandshakeError, Framed<T, Codec>);
-    type InitError = ();
-    type Service = VerifyWebSockets<T, C>;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &C) -> Self::Future {
-        ok(VerifyWebSockets { _t: PhantomData })
-    }
-}
-
-impl<T, C> Service for VerifyWebSockets<T, C> {
-    type Request = (Request, Framed<T, Codec>);
-    type Response = (Request, Framed<T, Codec>);
-    type Error = (HandshakeError, Framed<T, Codec>);
-    type Future = FutureResult<Self::Response, Self::Error>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
-        match verify_handshake(req.head()) {
-            Err(e) => Err((e, framed)).into_future(),
-            Ok(_) => Ok((req, framed)).into_future(),
-        }
-    }
-}
-
-/// Send http/1 error response
-pub struct SendError<T, R, E, C>(PhantomData<(T, R, E, C)>);
-
-impl<T, R, E, C> Default for SendError<T, R, E, C>
-where
-    T: AsyncRead + AsyncWrite,
-    E: ResponseError,
-{
-    fn default() -> Self {
-        SendError(PhantomData)
-    }
-}
-
-impl<T, R, E, C> NewService for SendError<T, R, E, C>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    R: 'static,
-    E: ResponseError + 'static,
-{
-    type Config = C;
-    type Request = Result<R, (E, Framed<T, Codec>)>;
-    type Response = R;
-    type Error = (E, Framed<T, Codec>);
-    type InitError = ();
-    type Service = SendError<T, R, E, C>;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &C) -> Self::Future {
-        ok(SendError(PhantomData))
-    }
-}
-
-impl<T, R, E, C> Service for SendError<T, R, E, C>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    R: 'static,
-    E: ResponseError + 'static,
-{
-    type Request = Result<R, (E, Framed<T, Codec>)>;
-    type Response = R;
-    type Error = (E, Framed<T, Codec>);
-    type Future = Either<FutureResult<R, (E, Framed<T, Codec>)>, SendErrorFut<T, R, E>>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Result<R, (E, Framed<T, Codec>)>) -> Self::Future {
-        match req {
-            Ok(r) => Either::A(ok(r)),
-            Err((e, framed)) => {
-                let res = e.error_response().drop_body();
-                Either::B(SendErrorFut {
-                    framed: Some(framed),
-                    res: Some((res, BodySize::Empty).into()),
-                    err: Some(e),
-                    _t: PhantomData,
-                })
-            }
-        }
-    }
-}
-
-pub struct SendErrorFut<T, R, E> {
-    res: Option<Message<(Response<()>, BodySize)>>,
-    framed: Option<Framed<T, Codec>>,
-    err: Option<E>,
-    _t: PhantomData<R>,
-}
-
-impl<T, R, E> Future for SendErrorFut<T, R, E>
-where
-    E: ResponseError,
-    T: AsyncRead + AsyncWrite,
-{
-    type Item = R;
-    type Error = (E, Framed<T, Codec>);
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(res) = self.res.take() {
-            if self.framed.as_mut().unwrap().force_send(res).is_err() {
-                return Err((self.err.take().unwrap(), self.framed.take().unwrap()));
-            }
-        }
-        match self.framed.as_mut().unwrap().poll_complete() {
-            Ok(Async::Ready(_)) => {
-                Err((self.err.take().unwrap(), self.framed.take().unwrap()))
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(_) => Err((self.err.take().unwrap(), self.framed.take().unwrap())),
-        }
-    }
-}
--- a/actix-framed/src/state.rs
+++ b/actix-framed/src/state.rs
@@ -1,29 +0,0 @@
-use std::ops::Deref;
-use std::sync::Arc;
-
-/// Application state
-pub struct State<S>(Arc<S>);
-
-impl<S> State<S> {
-    pub fn new(state: S) -> State<S> {
-        State(Arc::new(state))
-    }
-
-    pub fn get_ref(&self) -> &S {
-        self.0.as_ref()
-    }
-}
-
-impl<S> Deref for State<S> {
-    type Target = S;
-
-    fn deref(&self) -> &S {
-        self.0.as_ref()
-    }
-}
-
-impl<S> Clone for State<S> {
-    fn clone(&self) -> State<S> {
-        State(self.0.clone())
-    }
-}
--- a/actix-framed/src/test.rs
+++ b/actix-framed/src/test.rs
@@ -1,153 +0,0 @@
-//! Various helpers for Actix applications to use during testing.
-use actix_codec::Framed;
-use actix_http::h1::Codec;
-use actix_http::http::header::{Header, HeaderName, IntoHeaderValue};
-use actix_http::http::{HttpTryFrom, Method, Uri, Version};
-use actix_http::test::{TestBuffer, TestRequest as HttpTestRequest};
-use actix_router::{Path, Url};
-use actix_rt::Runtime;
-use futures::IntoFuture;
-
-use crate::{FramedRequest, State};
-
-/// Test `Request` builder.
-pub struct TestRequest<S = ()> {
-    req: HttpTestRequest,
-    path: Path<Url>,
-    state: State<S>,
-}
-
-impl Default for TestRequest<()> {
-    fn default() -> TestRequest {
-        TestRequest {
-            req: HttpTestRequest::default(),
-            path: Path::new(Url::new(Uri::default())),
-            state: State::new(()),
-        }
-    }
-}
-
-impl TestRequest<()> {
-    /// Create TestRequest and set request uri
-    pub fn with_uri(path: &str) -> Self {
-        Self::get().uri(path)
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_hdr<H: Header>(hdr: H) -> Self {
-        Self::default().set(hdr)
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_header<K, V>(key: K, value: V) -> Self
-    where
-        HeaderName: HttpTryFrom<K>,
-        V: IntoHeaderValue,
-    {
-        Self::default().header(key, value)
-    }
-
-    /// Create TestRequest and set method to `Method::GET`
-    pub fn get() -> Self {
-        Self::default().method(Method::GET)
-    }
-
-    /// Create TestRequest and set method to `Method::POST`
-    pub fn post() -> Self {
-        Self::default().method(Method::POST)
-    }
-}
-
-impl<S> TestRequest<S> {
-    /// Create TestRequest and set request uri
-    pub fn with_state(state: S) -> TestRequest<S> {
-        let req = TestRequest::get();
-        TestRequest {
-            state: State::new(state),
-            req: req.req,
-            path: req.path,
-        }
-    }
-
-    /// Set HTTP version of this request
-    pub fn version(mut self, ver: Version) -> Self {
-        self.req.version(ver);
-        self
-    }
-
-    /// Set HTTP method of this request
-    pub fn method(mut self, meth: Method) -> Self {
-        self.req.method(meth);
-        self
-    }
-
-    /// Set HTTP Uri of this request
-    pub fn uri(mut self, path: &str) -> Self {
-        self.req.uri(path);
-        self
-    }
-
-    /// Set a header
-    pub fn set<H: Header>(mut self, hdr: H) -> Self {
-        self.req.set(hdr);
-        self
-    }
-
-    /// Set a header
-    pub fn header<K, V>(mut self, key: K, value: V) -> Self
-    where
-        HeaderName: HttpTryFrom<K>,
-        V: IntoHeaderValue,
-    {
-        self.req.header(key, value);
-        self
-    }
-
-    /// Set request path pattern parameter
-    pub fn param(mut self, name: &'static str, value: &'static str) -> Self {
-        self.path.add_static(name, value);
-        self
-    }
-
-    /// Complete request creation and generate `Request` instance
-    pub fn finish(mut self) -> FramedRequest<TestBuffer, S> {
-        let req = self.req.finish();
-        self.path.get_mut().update(req.uri());
-        let framed = Framed::new(TestBuffer::empty(), Codec::default());
-        FramedRequest::new(req, framed, self.path, self.state)
-    }
-
-    /// This method generates `FramedRequest` instance and executes async handler
-    pub fn run<F, R, I, E>(self, f: F) -> Result<I, E>
-    where
-        F: FnOnce(FramedRequest<TestBuffer, S>) -> R,
-        R: IntoFuture<Item = I, Error = E>,
-    {
-        let mut rt = Runtime::new().unwrap();
-        rt.block_on(f(self.finish()).into_future())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test() {
-        let req = TestRequest::with_uri("/index.html")
-            .header("x-test", "test")
-            .param("test", "123")
-            .finish();
-
-        assert_eq!(*req.state(), ());
-        assert_eq!(req.version(), Version::HTTP_11);
-        assert_eq!(req.method(), Method::GET);
-        assert_eq!(req.path(), "/index.html");
-        assert_eq!(req.query_string(), "");
-        assert_eq!(
-            req.headers().get("x-test").unwrap().to_str().unwrap(),
-            "test"
-        );
-        assert_eq!(&req.match_info()["test"], "123");
-    }
-}
--- a/actix-framed/tests/test_server.rs
+++ b/actix-framed/tests/test_server.rs
@@ -1,141 +0,0 @@
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_http::{body, http::StatusCode, ws, Error, HttpService, Response};
-use actix_http_test::TestServer;
-use actix_service::{IntoNewService, NewService};
-use actix_utils::framed::FramedTransport;
-use bytes::{Bytes, BytesMut};
-use futures::future::{self, ok};
-use futures::{Future, Sink, Stream};
-
-use actix_framed::{FramedApp, FramedRequest, FramedRoute, SendError, VerifyWebSockets};
-
-fn ws_service<T: AsyncRead + AsyncWrite>(
-    req: FramedRequest<T>,
-) -> impl Future<Item = (), Error = Error> {
-    let (req, framed, _) = req.into_parts();
-    let res = ws::handshake(req.head()).unwrap().message_body(());
-
-    framed
-        .send((res, body::BodySize::None).into())
-        .map_err(|_| panic!())
-        .and_then(|framed| {
-            FramedTransport::new(framed.into_framed(ws::Codec::new()), service)
-                .map_err(|_| panic!())
-        })
-}
-
-fn service(msg: ws::Frame) -> impl Future<Item = ws::Message, Error = Error> {
-    let msg = match msg {
-        ws::Frame::Ping(msg) => ws::Message::Pong(msg),
-        ws::Frame::Text(text) => {
-            ws::Message::Text(String::from_utf8_lossy(&text.unwrap()).to_string())
-        }
-        ws::Frame::Binary(bin) => ws::Message::Binary(bin.unwrap().freeze()),
-        ws::Frame::Close(reason) => ws::Message::Close(reason),
-        _ => panic!(),
-    };
-    ok(msg)
-}
-
-#[test]
-fn test_simple() {
-    let mut srv = TestServer::new(|| {
-        HttpService::build()
-            .upgrade(
-                FramedApp::new().service(FramedRoute::get("/index.html").to(ws_service)),
-            )
-            .finish(|_| future::ok::<_, Error>(Response::NotFound()))
-    });
-
-    assert!(srv.ws_at("/test").is_err());
-
-    // client service
-    let framed = srv.ws_at("/index.html").unwrap();
-    let framed = srv
-        .block_on(framed.send(ws::Message::Text("text".to_string())))
-        .unwrap();
-    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(item, Some(ws::Frame::Text(Some(BytesMut::from("text")))));
-
-    let framed = srv
-        .block_on(framed.send(ws::Message::Binary("text".into())))
-        .unwrap();
-    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(
-        item,
-        Some(ws::Frame::Binary(Some(Bytes::from_static(b"text").into())))
-    );
-
-    let framed = srv
-        .block_on(framed.send(ws::Message::Ping("text".into())))
-        .unwrap();
-    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(item, Some(ws::Frame::Pong("text".to_string().into())));
-
-    let framed = srv
-        .block_on(framed.send(ws::Message::Close(Some(ws::CloseCode::Normal.into()))))
-        .unwrap();
-
-    let (item, _framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(
-        item,
-        Some(ws::Frame::Close(Some(ws::CloseCode::Normal.into())))
-    );
-}
-
-#[test]
-fn test_service() {
-    let mut srv = TestServer::new(|| {
-        actix_http::h1::OneRequest::new().map_err(|_| ()).and_then(
-            VerifyWebSockets::default()
-                .then(SendError::default())
-                .map_err(|_| ())
-                .and_then(
-                    FramedApp::new()
-                        .service(FramedRoute::get("/index.html").to(ws_service))
-                        .into_new_service()
-                        .map_err(|_| ()),
-                ),
-        )
-    });
-
-    // non ws request
-    let res = srv.block_on(srv.get("/index.html").send()).unwrap();
-    assert_eq!(res.status(), StatusCode::BAD_REQUEST);
-
-    // not found
-    assert!(srv.ws_at("/test").is_err());
-
-    // client service
-    let framed = srv.ws_at("/index.html").unwrap();
-    let framed = srv
-        .block_on(framed.send(ws::Message::Text("text".to_string())))
-        .unwrap();
-    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(item, Some(ws::Frame::Text(Some(BytesMut::from("text")))));
-
-    let framed = srv
-        .block_on(framed.send(ws::Message::Binary("text".into())))
-        .unwrap();
-    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(
-        item,
-        Some(ws::Frame::Binary(Some(Bytes::from_static(b"text").into())))
-    );
-
-    let framed = srv
-        .block_on(framed.send(ws::Message::Ping("text".into())))
-        .unwrap();
-    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(item, Some(ws::Frame::Pong("text".to_string().into())));
-
-    let framed = srv
-        .block_on(framed.send(ws::Message::Close(Some(ws::CloseCode::Normal.into()))))
-        .unwrap();
-
-    let (item, _framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
-    assert_eq!(
-        item,
-        Some(ws::Frame::Close(Some(ws::CloseCode::Normal.into())))
-    );
-}
--- a/actix-http/.appveyor.yml
+++ b/actix-http/.appveyor.yml
@@ -1,41 +0,0 @@
-environment:
-  global:
-    PROJECT_NAME: actix-http
-  matrix:
-    # Stable channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: stable
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: stable
-    # Nightly channel
-    - TARGET: i686-pc-windows-msvc
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-gnu
-      CHANNEL: nightly
-    - TARGET: x86_64-pc-windows-msvc
-      CHANNEL: nightly
-
-# Install Rust and Cargo
-# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
-install:
-  - ps: >-
-        If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
-           $Env:PATH += ';C:\msys64\mingw64\bin'
-        } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
-           $Env:PATH += ';C:\MinGW\bin'
-        }
-  - curl -sSf -o rustup-init.exe https://win.rustup.rs
-  - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -Vv
-  - cargo -V
-
-# 'cargo test' takes care of building for us, so disable Appveyor's build stage.
-build: false
-
-# Equivalent to Travis' `script` phase
-test_script:
-  - cargo clean
-  - cargo test
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@@ -1,259 +0,0 @@
-# Changes
-
-## [0.2.11] - 2019-11-06
-
-### Added
-
-* Add support for serde_json::Value to be passed as argument to ResponseBuilder.body()
-
-* Add an additional `filename*` param in the `Content-Disposition` header of `actix_files::NamedFile` to be more compatible. (#1151)
-
-* Allow to use `std::convert::Infallible` as `actix_http::error::Error`
-
-### Fixed
-
-* To be compatible with non-English error responses, `ResponseError` rendered with `text/plain; charset=utf-8` header #1118
-
-
-## [0.2.10] - 2019-09-11
-
-### Added
-
-* Add support for sending HTTP requests with `Rc<RequestHead>` in addition to sending HTTP requests with `RequestHead`
-
-### Fixed
-
-* h2 will use error response #1080
-
-* on_connect result isn't added to request extensions for http2 requests #1009
-
-
-## [0.2.9] - 2019-08-13
-
-### Changed
-
-* Dropped the `byteorder`-dependency in favor of `stdlib`-implementation
-
-* Update percent-encoding to 2.1
-
-* Update serde_urlencoded to 0.6.1
-
-### Fixed
-
-* Fixed a panic in the HTTP2 handshake in client HTTP requests (#1031)
-
-
-## [0.2.8] - 2019-08-01
-
-### Added
-
-* Add `rustls` support
-
-* Add `Clone` impl for `HeaderMap`
-
-### Fixed
-
-* awc client panic #1016
-
-* Invalid response with compression middleware enabled, but compression-related features disabled #997
-
-
-## [0.2.7] - 2019-07-18
-
-### Added
-
-* Add support for downcasting response errors #986
-
-
-## [0.2.6] - 2019-07-17
-
-### Changed
-
-* Replace `ClonableService` with local copy
-
-* Upgrade `rand` dependency version to 0.7
-
-
-## [0.2.5] - 2019-06-28
-
-### Added
-
-* Add `on-connect` callback, `HttpServiceBuilder::on_connect()` #946
-
-### Changed
-
-* Use `encoding_rs` crate instead of unmaintained `encoding` crate
-
-* Add `Copy` and `Clone` impls for `ws::Codec`
-
-
-## [0.2.4] - 2019-06-16
-
-### Fixed
-
-* Do not compress NoContent (204) responses #918
-
-
-## [0.2.3] - 2019-06-02
-
-### Added
-
-* Debug impl for ResponseBuilder
-
-* From SizedStream and BodyStream for Body
-
-### Changed
-
-* SizedStream uses u64
-
-
-## [0.2.2] - 2019-05-29
-
-### Fixed
-
-* Parse incoming stream before closing stream on disconnect #868
-
-
-## [0.2.1] - 2019-05-25
-
-### Fixed
-
-* Handle socket read disconnect
-
-
-## [0.2.0] - 2019-05-12
-
-### Changed
-
-* Update actix-service to 0.4
-
-* Expect and upgrade services accept `ServerConfig` config.
-
-### Deleted
-
-* `OneRequest` service
-
-
-## [0.1.5] - 2019-05-04
-
-### Fixed
-
-* Clean up response extensions in response pool #817
-
-
-## [0.1.4] - 2019-04-24
-
-### Added
-
-* Allow to render h1 request headers in `Camel-Case`
-
-### Fixed
-
-* Read until eof for http/1.0 responses #771
-
-
-## [0.1.3] - 2019-04-23
-
-### Fixed
-
-* Fix http client pool management
-
-* Fix http client wait queue management #794
-
-
-## [0.1.2] - 2019-04-23
-
-### Fixed
-
-* Fix BorrowMutError panic in client connector #793
-
-
-## [0.1.1] - 2019-04-19
-
-### Changed
-
-* Cookie::max_age() accepts value in seconds
-
-* Cookie::max_age_time() accepts value in time::Duration
-
-* Allow to specify server address for client connector
-
-
-## [0.1.0] - 2019-04-16
-
-### Added
-
-* Expose peer addr via `Request::peer_addr()` and `RequestHead::peer_addr`
-
-### Changed
-
-* `actix_http::encoding` always available
-
-* use trust-dns-resolver 0.11.0
-
-
-## [0.1.0-alpha.5] - 2019-04-12
-
-### Added
-
-* Allow to use custom service for upgrade requests
-
-* Added `h1::SendResponse` future.
-
-### Changed
-
-* MessageBody::length() renamed to MessageBody::size() for consistency
-
-* ws handshake verification functions take RequestHead instead of Request
-
-
-## [0.1.0-alpha.4] - 2019-04-08
-
-### Added
-
-* Allow to use custom `Expect` handler
-
-* Add minimal `std::error::Error` impl for `Error`
-
-### Changed
-
-* Export IntoHeaderValue
-
-* Render error and return as response body
-
-* Use thread pool for response body comression
-
-### Deleted
-
-* Removed PayloadBuffer
-
-
-## [0.1.0-alpha.3] - 2019-04-02
-
-### Added
-
-* Warn when an unsealed private cookie isn't valid UTF-8
-
-### Fixed
-
-* Rust 1.31.0 compatibility
-
-* Preallocate read buffer for h1 codec
-
-* Detect socket disconnection during protocol selection
-
-
-## [0.1.0-alpha.2] - 2019-03-29
-
-### Added
-
-* Added ws::Message::Nop, no-op websockets message
-
-### Changed
-
-* Do not use thread pool for decomression if chunk size is smaller than 2048.
-
-
-## [0.1.0-alpha.1] - 2019-03-28
-
-* Initial impl
--- a/actix-http/CODE_OF_CONDUCT.md
+++ b/actix-http/CODE_OF_CONDUCT.md
@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at fafhrd91@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@@ -1,110 +0,0 @@
-[package]
-name = "actix-http"
-version = "0.2.11"
-authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix http primitives"
-readme = "README.md"
-keywords = ["actix", "http", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web.git"
-documentation = "https://docs.rs/actix-http/"
-categories = ["network-programming", "asynchronous",
-              "web-programming::http-server",
-              "web-programming::websocket"]
-license = "MIT/Apache-2.0"
-edition = "2018"
-workspace = ".."
-
-[package.metadata.docs.rs]
-features = ["ssl", "fail", "brotli", "flate2-zlib", "secure-cookies"]
-
-[lib]
-name = "actix_http"
-path = "src/lib.rs"
-
-[features]
-default = []
-
-# openssl
-ssl = ["openssl", "actix-connect/ssl"]
-
-# rustls support
-rust-tls = ["rustls", "webpki-roots", "actix-connect/rust-tls"]
-
-# brotli encoding, requires c compiler
-brotli = ["brotli2"]
-
-# miniz-sys backend for flate2 crate
-flate2-zlib = ["flate2/miniz-sys"]
-
-# rust backend for flate2 crate
-flate2-rust = ["flate2/rust_backend"]
-
-# failure integration. actix does not use failure anymore
-fail = ["failure"]
-
-# support for secure cookies
-secure-cookies = ["ring"]
-
-[dependencies]
-actix-service = "0.4.1"
-actix-codec = "0.1.2"
-actix-connect = "0.2.4"
-actix-utils = "0.4.4"
-actix-server-config = "0.1.2"
-actix-threadpool = "0.1.1"
-
-base64 = "0.10"
-bitflags = "1.0"
-bytes = "0.4"
-copyless = "0.1.4"
-derive_more = "0.15.0"
-either = "1.5.2"
-encoding_rs = "0.8"
-futures = "0.1.25"
-hashbrown = "0.6.3"
-h2 = "0.1.16"
-http = "0.1.17"
-httparse = "1.3"
-indexmap = "1.2"
-lazy_static = "1.0"
-language-tags = "0.2"
-log = "0.4"
-mime = "0.3"
-percent-encoding = "2.1"
-rand = "0.7"
-regex = "1.0"
-serde = "1.0"
-serde_json = "1.0"
-sha1 = "0.6"
-slab = "0.4"
-serde_urlencoded = "0.6.1"
-time = "0.1.42"
-tokio-tcp = "0.1.3"
-tokio-timer = "0.2.8"
-tokio-current-thread = "0.1"
-trust-dns-resolver = { version="0.11.1", default-features = false }
-
-# for secure cookie
-ring = { version = "0.14.6", optional = true }
-
-# compression
-brotli2 = { version="0.3.2", optional = true }
-flate2 = { version="1.0.7", optional = true, default-features = false }
-
-# optional deps
-failure = { version = "0.1.5", optional = true }
-openssl = { version="0.10", optional = true }
-rustls = { version = "0.15.2", optional = true }
-webpki-roots = { version = "0.16", optional = true }
-chrono = "0.4.6"
-
-[dev-dependencies]
-actix-rt = "0.2.2"
-actix-server = { version = "0.6.0", features=["ssl", "rust-tls"] }
-actix-connect = { version = "0.2.0", features=["ssl"] }
-actix-http-test = { version = "0.2.4", features=["ssl"] }
-env_logger = "0.6"
-serde_derive = "1.0"
-openssl = { version="0.10" }
-tokio-tcp = "0.1"
--- a/actix-http/LICENSE-APACHE
+++ b/actix-http/LICENSE-APACHE
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2017-NOW Nikolay Kim
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--- a/actix-http/LICENSE-MIT
+++ b/actix-http/LICENSE-MIT
@@ -1,25 +0,0 @@
-Copyright (c) 2017 Nikolay Kim
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
--- a/actix-http/README.md
+++ b/actix-http/README.md
@@ -1,46 +0,0 @@
-# Actix http [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web)  [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-http)](https://crates.io/crates/actix-http) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-Actix http
-
-## Documentation & community resources
-
-* [User Guide](https://actix.rs/docs/)
-* [API Documentation](https://docs.rs/actix-http/)
-* [Chat on gitter](https://gitter.im/actix/actix)
-* Cargo package: [actix-http](https://crates.io/crates/actix-http)
-* Minimum supported Rust version: 1.31 or later
-
-## Example
-
-```rust
-// see examples/framed_hello.rs for complete list of used crates.
-extern crate actix_http;
-use actix_http::{h1, Response, ServiceConfig};
-
-fn main() {
-    Server::new().bind("framed_hello", "127.0.0.1:8080", || {
-        IntoFramed::new(|| h1::Codec::new(ServiceConfig::default()))	// <- create h1 codec
-            .and_then(TakeItem::new().map_err(|_| ()))	                // <- read one request
-            .and_then(|(_req, _framed): (_, Framed<_, _>)| {	        // <- send response and close conn
-                SendResponse::send(_framed, Response::Ok().body("Hello world!"))
-                    .map_err(|_| ())
-                    .map(|_| ())
-            })
-    }).unwrap().run();
-}
-```
-
-## License
-
-This project is licensed under either of
-
-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
-
-at your option.
-
-## Code of Conduct
-
-Contribution to the actix-http crate is organized under the terms of the
-Contributor Covenant, the maintainer of actix-http, @fafhrd91, promises to
-intervene to uphold that code of conduct.
--- a/actix-http/examples/echo.rs
+++ b/actix-http/examples/echo.rs
@@ -1,37 +0,0 @@
-use std::{env, io};
-
-use actix_http::{error::PayloadError, HttpService, Request, Response};
-use actix_server::Server;
-use bytes::BytesMut;
-use futures::{Future, Stream};
-use http::header::HeaderValue;
-use log::info;
-
-fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "echo=info");
-    env_logger::init();
-
-    Server::build()
-        .bind("echo", "127.0.0.1:8080", || {
-            HttpService::build()
-                .client_timeout(1000)
-                .client_disconnect(1000)
-                .finish(|mut req: Request| {
-                    req.take_payload()
-                        .fold(BytesMut::new(), move |mut body, chunk| {
-                            body.extend_from_slice(&chunk);
-                            Ok::<_, PayloadError>(body)
-                        })
-                        .and_then(|bytes| {
-                            info!("request body: {:?}", bytes);
-                            let mut res = Response::Ok();
-                            res.header(
-                                "x-head",
-                                HeaderValue::from_static("dummy value!"),
-                            );
-                            Ok(res.body(bytes))
-                        })
-                })
-        })?
-        .run()
-}
--- a/actix-http/examples/echo2.rs
+++ b/actix-http/examples/echo2.rs
@@ -1,34 +0,0 @@
-use std::{env, io};
-
-use actix_http::http::HeaderValue;
-use actix_http::{error::PayloadError, Error, HttpService, Request, Response};
-use actix_server::Server;
-use bytes::BytesMut;
-use futures::{Future, Stream};
-use log::info;
-
-fn handle_request(mut req: Request) -> impl Future<Item = Response, Error = Error> {
-    req.take_payload()
-        .fold(BytesMut::new(), move |mut body, chunk| {
-            body.extend_from_slice(&chunk);
-            Ok::<_, PayloadError>(body)
-        })
-        .from_err()
-        .and_then(|bytes| {
-            info!("request body: {:?}", bytes);
-            let mut res = Response::Ok();
-            res.header("x-head", HeaderValue::from_static("dummy value!"));
-            Ok(res.body(bytes))
-        })
-}
-
-fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "echo=info");
-    env_logger::init();
-
-    Server::build()
-        .bind("echo", "127.0.0.1:8080", || {
-            HttpService::build().finish(|_req: Request| handle_request(_req))
-        })?
-        .run()
-}
--- a/actix-http/examples/hello-world.rs
+++ b/actix-http/examples/hello-world.rs
@@ -1,26 +0,0 @@
-use std::{env, io};
-
-use actix_http::{HttpService, Response};
-use actix_server::Server;
-use futures::future;
-use http::header::HeaderValue;
-use log::info;
-
-fn main() -> io::Result<()> {
-    env::set_var("RUST_LOG", "hello_world=info");
-    env_logger::init();
-
-    Server::build()
-        .bind("hello-world", "127.0.0.1:8080", || {
-            HttpService::build()
-                .client_timeout(1000)
-                .client_disconnect(1000)
-                .finish(|_req| {
-                    info!("{:?}", _req);
-                    let mut res = Response::Ok();
-                    res.header("x-head", HeaderValue::from_static("dummy value!"));
-                    future::ok::<_, ()>(res.body("Hello world!"))
-                })
-        })?
-        .run()
-}
--- a/actix-http/rustfmt.toml
+++ b/actix-http/rustfmt.toml
@@ -1,5 +0,0 @@
-max_width = 89
-reorder_imports = true
-#wrap_comments = true
-#fn_args_density = "Compressed"
-#use_small_heuristics = false
--- a/actix-http/src/body.rs
+++ b/actix-http/src/body.rs
@@ -1,570 +0,0 @@
-use std::marker::PhantomData;
-use std::{fmt, mem};
-
-use bytes::{Bytes, BytesMut};
-use futures::{Async, Poll, Stream};
-
-use crate::error::Error;
-
-#[derive(Debug, PartialEq, Copy, Clone)]
-/// Body size hint
-pub enum BodySize {
-    None,
-    Empty,
-    Sized(usize),
-    Sized64(u64),
-    Stream,
-}
-
-impl BodySize {
-    pub fn is_eof(&self) -> bool {
-        match self {
-            BodySize::None
-            | BodySize::Empty
-            | BodySize::Sized(0)
-            | BodySize::Sized64(0) => true,
-            _ => false,
-        }
-    }
-}
-
-/// Type that provides this trait can be streamed to a peer.
-pub trait MessageBody {
-    fn size(&self) -> BodySize;
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error>;
-}
-
-impl MessageBody for () {
-    fn size(&self) -> BodySize {
-        BodySize::Empty
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        Ok(Async::Ready(None))
-    }
-}
-
-impl<T: MessageBody> MessageBody for Box<T> {
-    fn size(&self) -> BodySize {
-        self.as_ref().size()
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        self.as_mut().poll_next()
-    }
-}
-
-pub enum ResponseBody<B> {
-    Body(B),
-    Other(Body),
-}
-
-impl ResponseBody<Body> {
-    pub fn into_body<B>(self) -> ResponseBody<B> {
-        match self {
-            ResponseBody::Body(b) => ResponseBody::Other(b),
-            ResponseBody::Other(b) => ResponseBody::Other(b),
-        }
-    }
-}
-
-impl<B> ResponseBody<B> {
-    pub fn take_body(&mut self) -> ResponseBody<B> {
-        std::mem::replace(self, ResponseBody::Other(Body::None))
-    }
-}
-
-impl<B: MessageBody> ResponseBody<B> {
-    pub fn as_ref(&self) -> Option<&B> {
-        if let ResponseBody::Body(ref b) = self {
-            Some(b)
-        } else {
-            None
-        }
-    }
-}
-
-impl<B: MessageBody> MessageBody for ResponseBody<B> {
-    fn size(&self) -> BodySize {
-        match self {
-            ResponseBody::Body(ref body) => body.size(),
-            ResponseBody::Other(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        match self {
-            ResponseBody::Body(ref mut body) => body.poll_next(),
-            ResponseBody::Other(ref mut body) => body.poll_next(),
-        }
-    }
-}
-
-impl<B: MessageBody> Stream for ResponseBody<B> {
-    type Item = Bytes;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        self.poll_next()
-    }
-}
-
-/// Represents various types of http message body.
-pub enum Body {
-    /// Empty response. `Content-Length` header is not set.
-    None,
-    /// Zero sized response body. `Content-Length` header is set to `0`.
-    Empty,
-    /// Specific response body.
-    Bytes(Bytes),
-    /// Generic message body.
-    Message(Box<dyn MessageBody>),
-}
-
-impl Body {
-    /// Create body from slice (copy)
-    pub fn from_slice(s: &[u8]) -> Body {
-        Body::Bytes(Bytes::from(s))
-    }
-
-    /// Create body from generic message body.
-    pub fn from_message<B: MessageBody + 'static>(body: B) -> Body {
-        Body::Message(Box::new(body))
-    }
-}
-
-impl MessageBody for Body {
-    fn size(&self) -> BodySize {
-        match self {
-            Body::None => BodySize::None,
-            Body::Empty => BodySize::Empty,
-            Body::Bytes(ref bin) => BodySize::Sized(bin.len()),
-            Body::Message(ref body) => body.size(),
-        }
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        match self {
-            Body::None => Ok(Async::Ready(None)),
-            Body::Empty => Ok(Async::Ready(None)),
-            Body::Bytes(ref mut bin) => {
-                let len = bin.len();
-                if len == 0 {
-                    Ok(Async::Ready(None))
-                } else {
-                    Ok(Async::Ready(Some(mem::replace(bin, Bytes::new()))))
-                }
-            }
-            Body::Message(ref mut body) => body.poll_next(),
-        }
-    }
-}
-
-impl PartialEq for Body {
-    fn eq(&self, other: &Body) -> bool {
-        match *self {
-            Body::None => match *other {
-                Body::None => true,
-                _ => false,
-            },
-            Body::Empty => match *other {
-                Body::Empty => true,
-                _ => false,
-            },
-            Body::Bytes(ref b) => match *other {
-                Body::Bytes(ref b2) => b == b2,
-                _ => false,
-            },
-            Body::Message(_) => false,
-        }
-    }
-}
-
-impl fmt::Debug for Body {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Body::None => write!(f, "Body::None"),
-            Body::Empty => write!(f, "Body::Empty"),
-            Body::Bytes(ref b) => write!(f, "Body::Bytes({:?})", b),
-            Body::Message(_) => write!(f, "Body::Message(_)"),
-        }
-    }
-}
-
-impl From<&'static str> for Body {
-    fn from(s: &'static str) -> Body {
-        Body::Bytes(Bytes::from_static(s.as_ref()))
-    }
-}
-
-impl From<&'static [u8]> for Body {
-    fn from(s: &'static [u8]) -> Body {
-        Body::Bytes(Bytes::from_static(s))
-    }
-}
-
-impl From<Vec<u8>> for Body {
-    fn from(vec: Vec<u8>) -> Body {
-        Body::Bytes(Bytes::from(vec))
-    }
-}
-
-impl From<String> for Body {
-    fn from(s: String) -> Body {
-        s.into_bytes().into()
-    }
-}
-
-impl<'a> From<&'a String> for Body {
-    fn from(s: &'a String) -> Body {
-        Body::Bytes(Bytes::from(AsRef::<[u8]>::as_ref(&s)))
-    }
-}
-
-impl From<Bytes> for Body {
-    fn from(s: Bytes) -> Body {
-        Body::Bytes(s)
-    }
-}
-
-impl From<BytesMut> for Body {
-    fn from(s: BytesMut) -> Body {
-        Body::Bytes(s.freeze())
-    }
-}
-
-impl From<serde_json::Value> for Body {
-    fn from(v: serde_json::Value) -> Body {
-        Body::Bytes(v.to_string().into())
-    }
-}
-
-impl<S> From<SizedStream<S>> for Body
-where
-    S: Stream<Item = Bytes, Error = Error> + 'static,
-{
-    fn from(s: SizedStream<S>) -> Body {
-        Body::from_message(s)
-    }
-}
-
-impl<S, E> From<BodyStream<S, E>> for Body
-where
-    S: Stream<Item = Bytes, Error = E> + 'static,
-    E: Into<Error> + 'static,
-{
-    fn from(s: BodyStream<S, E>) -> Body {
-        Body::from_message(s)
-    }
-}
-
-impl MessageBody for Bytes {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        if self.is_empty() {
-            Ok(Async::Ready(None))
-        } else {
-            Ok(Async::Ready(Some(mem::replace(self, Bytes::new()))))
-        }
-    }
-}
-
-impl MessageBody for BytesMut {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        if self.is_empty() {
-            Ok(Async::Ready(None))
-        } else {
-            Ok(Async::Ready(Some(
-                mem::replace(self, BytesMut::new()).freeze(),
-            )))
-        }
-    }
-}
-
-impl MessageBody for &'static str {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        if self.is_empty() {
-            Ok(Async::Ready(None))
-        } else {
-            Ok(Async::Ready(Some(Bytes::from_static(
-                mem::replace(self, "").as_ref(),
-            ))))
-        }
-    }
-}
-
-impl MessageBody for &'static [u8] {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        if self.is_empty() {
-            Ok(Async::Ready(None))
-        } else {
-            Ok(Async::Ready(Some(Bytes::from_static(mem::replace(
-                self, b"",
-            )))))
-        }
-    }
-}
-
-impl MessageBody for Vec<u8> {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        if self.is_empty() {
-            Ok(Async::Ready(None))
-        } else {
-            Ok(Async::Ready(Some(Bytes::from(mem::replace(
-                self,
-                Vec::new(),
-            )))))
-        }
-    }
-}
-
-impl MessageBody for String {
-    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len())
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        if self.is_empty() {
-            Ok(Async::Ready(None))
-        } else {
-            Ok(Async::Ready(Some(Bytes::from(
-                mem::replace(self, String::new()).into_bytes(),
-            ))))
-        }
-    }
-}
-
-/// Type represent streaming body.
-/// Response does not contain `content-length` header and appropriate transfer encoding is used.
-pub struct BodyStream<S, E> {
-    stream: S,
-    _t: PhantomData<E>,
-}
-
-impl<S, E> BodyStream<S, E>
-where
-    S: Stream<Item = Bytes, Error = E>,
-    E: Into<Error>,
-{
-    pub fn new(stream: S) -> Self {
-        BodyStream {
-            stream,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<S, E> MessageBody for BodyStream<S, E>
-where
-    S: Stream<Item = Bytes, Error = E>,
-    E: Into<Error>,
-{
-    fn size(&self) -> BodySize {
-        BodySize::Stream
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        self.stream.poll().map_err(std::convert::Into::into)
-    }
-}
-
-/// Type represent streaming body. This body implementation should be used
-/// if total size of stream is known. Data get sent as is without using transfer encoding.
-pub struct SizedStream<S> {
-    size: u64,
-    stream: S,
-}
-
-impl<S> SizedStream<S>
-where
-    S: Stream<Item = Bytes, Error = Error>,
-{
-    pub fn new(size: u64, stream: S) -> Self {
-        SizedStream { size, stream }
-    }
-}
-
-impl<S> MessageBody for SizedStream<S>
-where
-    S: Stream<Item = Bytes, Error = Error>,
-{
-    fn size(&self) -> BodySize {
-        BodySize::Sized64(self.size)
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        self.stream.poll()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    impl Body {
-        pub(crate) fn get_ref(&self) -> &[u8] {
-            match *self {
-                Body::Bytes(ref bin) => &bin,
-                _ => panic!(),
-            }
-        }
-    }
-
-    impl ResponseBody<Body> {
-        pub(crate) fn get_ref(&self) -> &[u8] {
-            match *self {
-                ResponseBody::Body(ref b) => b.get_ref(),
-                ResponseBody::Other(ref b) => b.get_ref(),
-            }
-        }
-    }
-
-    #[test]
-    fn test_static_str() {
-        assert_eq!(Body::from("").size(), BodySize::Sized(0));
-        assert_eq!(Body::from("test").size(), BodySize::Sized(4));
-        assert_eq!(Body::from("test").get_ref(), b"test");
-
-        assert_eq!("test".size(), BodySize::Sized(4));
-        assert_eq!(
-            "test".poll_next().unwrap(),
-            Async::Ready(Some(Bytes::from("test")))
-        );
-    }
-
-    #[test]
-    fn test_static_bytes() {
-        assert_eq!(Body::from(b"test".as_ref()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b"test".as_ref()).get_ref(), b"test");
-        assert_eq!(
-            Body::from_slice(b"test".as_ref()).size(),
-            BodySize::Sized(4)
-        );
-        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
-
-        assert_eq!((&b"test"[..]).size(), BodySize::Sized(4));
-        assert_eq!(
-            (&b"test"[..]).poll_next().unwrap(),
-            Async::Ready(Some(Bytes::from("test")))
-        );
-    }
-
-    #[test]
-    fn test_vec() {
-        assert_eq!(Body::from(Vec::from("test")).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(Vec::from("test")).get_ref(), b"test");
-
-        assert_eq!(Vec::from("test").size(), BodySize::Sized(4));
-        assert_eq!(
-            Vec::from("test").poll_next().unwrap(),
-            Async::Ready(Some(Bytes::from("test")))
-        );
-    }
-
-    #[test]
-    fn test_bytes() {
-        let mut b = Bytes::from("test");
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            b.poll_next().unwrap(),
-            Async::Ready(Some(Bytes::from("test")))
-        );
-    }
-
-    #[test]
-    fn test_bytes_mut() {
-        let mut b = BytesMut::from("test");
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            b.poll_next().unwrap(),
-            Async::Ready(Some(Bytes::from("test")))
-        );
-    }
-
-    #[test]
-    fn test_string() {
-        let mut b = "test".to_owned();
-        assert_eq!(Body::from(b.clone()).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(b.clone()).get_ref(), b"test");
-        assert_eq!(Body::from(&b).size(), BodySize::Sized(4));
-        assert_eq!(Body::from(&b).get_ref(), b"test");
-
-        assert_eq!(b.size(), BodySize::Sized(4));
-        assert_eq!(
-            b.poll_next().unwrap(),
-            Async::Ready(Some(Bytes::from("test")))
-        );
-    }
-
-    #[test]
-    fn test_unit() {
-        assert_eq!(().size(), BodySize::Empty);
-        assert_eq!(().poll_next().unwrap(), Async::Ready(None));
-    }
-
-    #[test]
-    fn test_box() {
-        let mut val = Box::new(());
-        assert_eq!(val.size(), BodySize::Empty);
-        assert_eq!(val.poll_next().unwrap(), Async::Ready(None));
-    }
-
-    #[test]
-    fn test_body_eq() {
-        assert!(Body::None == Body::None);
-        assert!(Body::None != Body::Empty);
-        assert!(Body::Empty == Body::Empty);
-        assert!(Body::Empty != Body::None);
-        assert!(
-            Body::Bytes(Bytes::from_static(b"1"))
-                == Body::Bytes(Bytes::from_static(b"1"))
-        );
-        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
-    }
-
-    #[test]
-    fn test_body_debug() {
-        assert!(format!("{:?}", Body::None).contains("Body::None"));
-        assert!(format!("{:?}", Body::Empty).contains("Body::Empty"));
-        assert!(format!("{:?}", Body::Bytes(Bytes::from_static(b"1"))).contains("1"));
-    }
-
-    #[test]
-    fn test_serde_json() {
-        use serde_json::json;
-        assert_eq!(
-            Body::from(serde_json::Value::String("test".into())).size(),
-            BodySize::Sized(6)
-        );
-        assert_eq!(
-            Body::from(json!({"test-key":"test-value"})).size(),
-            BodySize::Sized(25)
-        );
-    }
-}
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@@ -1,225 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-use std::rc::Rc;
-
-use actix_codec::Framed;
-use actix_server_config::ServerConfig as SrvConfig;
-use actix_service::{IntoNewService, NewService, Service};
-
-use crate::body::MessageBody;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::Error;
-use crate::h1::{Codec, ExpectHandler, H1Service, UpgradeHandler};
-use crate::h2::H2Service;
-use crate::helpers::{Data, DataFactory};
-use crate::request::Request;
-use crate::response::Response;
-use crate::service::HttpService;
-
-/// A http service builder
-///
-/// This type can be used to construct an instance of `http service` through a
-/// builder-like pattern.
-pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
-    keep_alive: KeepAlive,
-    client_timeout: u64,
-    client_disconnect: u64,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, S)>,
-}
-
-impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-{
-    /// Create instance of `ServiceConfigBuilder`
-    pub fn new() -> Self {
-        HttpServiceBuilder {
-            keep_alive: KeepAlive::Timeout(5),
-            client_timeout: 5000,
-            client_disconnect: 0,
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: NewService<
-        Config = SrvConfig,
-        Request = (Request, Framed<T, Codec>),
-        Response = (),
-    >,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    /// Set server keep-alive setting.
-    ///
-    /// By default keep alive is set to a 5 seconds.
-    pub fn keep_alive<W: Into<KeepAlive>>(mut self, val: W) -> Self {
-        self.keep_alive = val.into();
-        self
-    }
-
-    /// Set server client timeout in milliseconds for first request.
-    ///
-    /// Defines a timeout for reading client request header. If a client does not transmit
-    /// the entire set headers within this time, the request is terminated with
-    /// the 408 (Request Time-out) error.
-    ///
-    /// To disable timeout set value to 0.
-    ///
-    /// By default client timeout is set to 5000 milliseconds.
-    pub fn client_timeout(mut self, val: u64) -> Self {
-        self.client_timeout = val;
-        self
-    }
-
-    /// Set server connection disconnect timeout in milliseconds.
-    ///
-    /// Defines a timeout for disconnect connection. If a disconnect procedure does not complete
-    /// within this time, the request get dropped. This timeout affects secure connections.
-    ///
-    /// To disable timeout set value to 0.
-    ///
-    /// By default disconnect timeout is set to 0.
-    pub fn client_disconnect(mut self, val: u64) -> Self {
-        self.client_disconnect = val;
-        self
-    }
-
-    /// Provide service for `EXPECT: 100-Continue` support.
-    ///
-    /// Service get called with request that contains `EXPECT` header.
-    /// Service must return request in case of success, in that case
-    /// request will be forwarded to main service.
-    pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U>
-    where
-        F: IntoNewService<X1>,
-        X1: NewService<Config = SrvConfig, Request = Request, Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-    {
-        HttpServiceBuilder {
-            keep_alive: self.keep_alive,
-            client_timeout: self.client_timeout,
-            client_disconnect: self.client_disconnect,
-            expect: expect.into_new_service(),
-            upgrade: self.upgrade,
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Provide service for custom `Connection: UPGRADE` support.
-    ///
-    /// If service is provided then normal requests handling get halted
-    /// and this service get called with original request and framed object.
-    pub fn upgrade<F, U1>(self, upgrade: F) -> HttpServiceBuilder<T, S, X, U1>
-    where
-        F: IntoNewService<U1>,
-        U1: NewService<
-            Config = SrvConfig,
-            Request = (Request, Framed<T, Codec>),
-            Response = (),
-        >,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-    {
-        HttpServiceBuilder {
-            keep_alive: self.keep_alive,
-            client_timeout: self.client_timeout,
-            client_disconnect: self.client_disconnect,
-            expect: self.expect,
-            upgrade: Some(upgrade.into_new_service()),
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on-connect callback.
-    ///
-    /// It get called once per connection and result of the call
-    /// get stored to the request's extensions.
-    pub fn on_connect<F, I>(mut self, f: F) -> Self
-    where
-        F: Fn(&T) -> I + 'static,
-        I: Clone + 'static,
-    {
-        self.on_connect = Some(Rc::new(move |io| Box::new(Data(f(io)))));
-        self
-    }
-
-    /// Finish service configuration and create *http service* for HTTP/1 protocol.
-    pub fn h1<F, P, B>(self, service: F) -> H1Service<T, P, S, B, X, U>
-    where
-        B: MessageBody + 'static,
-        F: IntoNewService<S>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-    {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_timeout,
-            self.client_disconnect,
-        );
-        H1Service::with_config(cfg, service.into_new_service())
-            .expect(self.expect)
-            .upgrade(self.upgrade)
-            .on_connect(self.on_connect)
-    }
-
-    /// Finish service configuration and create *http service* for HTTP/2 protocol.
-    pub fn h2<F, P, B>(self, service: F) -> H2Service<T, P, S, B>
-    where
-        B: MessageBody + 'static,
-        F: IntoNewService<S>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        <S::Service as Service>::Future: 'static,
-    {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_timeout,
-            self.client_disconnect,
-        );
-        H2Service::with_config(cfg, service.into_new_service())
-            .on_connect(self.on_connect)
-    }
-
-    /// Finish service configuration and create `HttpService` instance.
-    pub fn finish<F, P, B>(self, service: F) -> HttpService<T, P, S, B, X, U>
-    where
-        B: MessageBody + 'static,
-        F: IntoNewService<S>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        <S::Service as Service>::Future: 'static,
-    {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_timeout,
-            self.client_disconnect,
-        );
-        HttpService::with_config(cfg, service.into_new_service())
-            .expect(self.expect)
-            .upgrade(self.upgrade)
-            .on_connect(self.on_connect)
-    }
-}
--- a/actix-http/src/client/connection.rs
+++ b/actix-http/src/client/connection.rs
@@ -1,288 +0,0 @@
-use std::{fmt, io, time};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use bytes::{Buf, Bytes};
-use futures::future::{err, Either, Future, FutureResult};
-use futures::Poll;
-use h2::client::SendRequest;
-
-use crate::body::MessageBody;
-use crate::h1::ClientCodec;
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
-
-use super::error::SendRequestError;
-use super::pool::{Acquired, Protocol};
-use super::{h1proto, h2proto};
-
-pub(crate) enum ConnectionType<Io> {
-    H1(Io),
-    H2(SendRequest<Bytes>),
-}
-
-pub trait Connection {
-    type Io: AsyncRead + AsyncWrite;
-    type Future: Future<Item = (ResponseHead, Payload), Error = SendRequestError>;
-
-    fn protocol(&self) -> Protocol;
-
-    /// Send request and body
-    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
-        self,
-        head: H,
-        body: B,
-    ) -> Self::Future;
-
-    type TunnelFuture: Future<
-        Item = (ResponseHead, Framed<Self::Io, ClientCodec>),
-        Error = SendRequestError,
-    >;
-
-    /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture;
-}
-
-pub(crate) trait ConnectionLifetime: AsyncRead + AsyncWrite + 'static {
-    /// Close connection
-    fn close(&mut self);
-
-    /// Release connection to the connection pool
-    fn release(&mut self);
-}
-
-#[doc(hidden)]
-/// HTTP client connection
-pub struct IoConnection<T> {
-    io: Option<ConnectionType<T>>,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-}
-
-impl<T> fmt::Debug for IoConnection<T>
-where
-    T: fmt::Debug,
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self.io {
-            Some(ConnectionType::H1(ref io)) => write!(f, "H1Connection({:?})", io),
-            Some(ConnectionType::H2(_)) => write!(f, "H2Connection"),
-            None => write!(f, "Connection(Empty)"),
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite> IoConnection<T> {
-    pub(crate) fn new(
-        io: ConnectionType<T>,
-        created: time::Instant,
-        pool: Option<Acquired<T>>,
-    ) -> Self {
-        IoConnection {
-            pool,
-            created,
-            io: Some(io),
-        }
-    }
-
-    pub(crate) fn into_inner(self) -> (ConnectionType<T>, time::Instant) {
-        (self.io.unwrap(), self.created)
-    }
-}
-
-impl<T> Connection for IoConnection<T>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-{
-    type Io = T;
-    type Future =
-        Box<dyn Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;
-
-    fn protocol(&self) -> Protocol {
-        match self.io {
-            Some(ConnectionType::H1(_)) => Protocol::Http1,
-            Some(ConnectionType::H2(_)) => Protocol::Http2,
-            None => Protocol::Http1,
-        }
-    }
-
-    fn send_request<B: MessageBody + 'static, H: Into<RequestHeadType>>(
-        mut self,
-        head: H,
-        body: B,
-    ) -> Self::Future {
-        match self.io.take().unwrap() {
-            ConnectionType::H1(io) => Box::new(h1proto::send_request(
-                io,
-                head.into(),
-                body,
-                self.created,
-                self.pool,
-            )),
-            ConnectionType::H2(io) => Box::new(h2proto::send_request(
-                io,
-                head.into(),
-                body,
-                self.created,
-                self.pool,
-            )),
-        }
-    }
-
-    type TunnelFuture = Either<
-        Box<
-            dyn Future<
-                Item = (ResponseHead, Framed<Self::Io, ClientCodec>),
-                Error = SendRequestError,
-            >,
-        >,
-        FutureResult<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
-    >;
-
-    /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(mut self, head: H) -> Self::TunnelFuture {
-        match self.io.take().unwrap() {
-            ConnectionType::H1(io) => {
-                Either::A(Box::new(h1proto::open_tunnel(io, head.into())))
-            }
-            ConnectionType::H2(io) => {
-                if let Some(mut pool) = self.pool.take() {
-                    pool.release(IoConnection::new(
-                        ConnectionType::H2(io),
-                        self.created,
-                        None,
-                    ));
-                }
-                Either::B(err(SendRequestError::TunnelNotSupported))
-            }
-        }
-    }
-}
-
-#[allow(dead_code)]
-pub(crate) enum EitherConnection<A, B> {
-    A(IoConnection<A>),
-    B(IoConnection<B>),
-}
-
-impl<A, B> Connection for EitherConnection<A, B>
-where
-    A: AsyncRead + AsyncWrite + 'static,
-    B: AsyncRead + AsyncWrite + 'static,
-{
-    type Io = EitherIo<A, B>;
-    type Future =
-        Box<dyn Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;
-
-    fn protocol(&self) -> Protocol {
-        match self {
-            EitherConnection::A(con) => con.protocol(),
-            EitherConnection::B(con) => con.protocol(),
-        }
-    }
-
-    fn send_request<RB: MessageBody + 'static, H: Into<RequestHeadType>>(
-        self,
-        head: H,
-        body: RB,
-    ) -> Self::Future {
-        match self {
-            EitherConnection::A(con) => con.send_request(head, body),
-            EitherConnection::B(con) => con.send_request(head, body),
-        }
-    }
-
-    type TunnelFuture = Box<
-        dyn Future<
-            Item = (ResponseHead, Framed<Self::Io, ClientCodec>),
-            Error = SendRequestError,
-        >,
-    >;
-
-    /// Send request, returns Response and Framed
-    fn open_tunnel<H: Into<RequestHeadType>>(self, head: H) -> Self::TunnelFuture {
-        match self {
-            EitherConnection::A(con) => Box::new(
-                con.open_tunnel(head)
-                    .map(|(head, framed)| (head, framed.map_io(EitherIo::A))),
-            ),
-            EitherConnection::B(con) => Box::new(
-                con.open_tunnel(head)
-                    .map(|(head, framed)| (head, framed.map_io(EitherIo::B))),
-            ),
-        }
-    }
-}
-
-pub enum EitherIo<A, B> {
-    A(A),
-    B(B),
-}
-
-impl<A, B> io::Read for EitherIo<A, B>
-where
-    A: io::Read,
-    B: io::Read,
-{
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        match self {
-            EitherIo::A(ref mut val) => val.read(buf),
-            EitherIo::B(ref mut val) => val.read(buf),
-        }
-    }
-}
-
-impl<A, B> AsyncRead for EitherIo<A, B>
-where
-    A: AsyncRead,
-    B: AsyncRead,
-{
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
-        match self {
-            EitherIo::A(ref val) => val.prepare_uninitialized_buffer(buf),
-            EitherIo::B(ref val) => val.prepare_uninitialized_buffer(buf),
-        }
-    }
-}
-
-impl<A, B> io::Write for EitherIo<A, B>
-where
-    A: io::Write,
-    B: io::Write,
-{
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match self {
-            EitherIo::A(ref mut val) => val.write(buf),
-            EitherIo::B(ref mut val) => val.write(buf),
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        match self {
-            EitherIo::A(ref mut val) => val.flush(),
-            EitherIo::B(ref mut val) => val.flush(),
-        }
-    }
-}
-
-impl<A, B> AsyncWrite for EitherIo<A, B>
-where
-    A: AsyncWrite,
-    B: AsyncWrite,
-{
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        match self {
-            EitherIo::A(ref mut val) => val.shutdown(),
-            EitherIo::B(ref mut val) => val.shutdown(),
-        }
-    }
-
-    fn write_buf<U: Buf>(&mut self, buf: &mut U) -> Poll<usize, io::Error>
-    where
-        Self: Sized,
-    {
-        match self {
-            EitherIo::A(ref mut val) => val.write_buf(buf),
-            EitherIo::B(ref mut val) => val.write_buf(buf),
-        }
-    }
-}
--- a/actix-http/src/client/connector.rs
+++ b/actix-http/src/client/connector.rs
@@ -1,540 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-use std::time::Duration;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_connect::{
-    default_connector, Connect as TcpConnect, Connection as TcpConnection,
-};
-use actix_service::{apply_fn, Service, ServiceExt};
-use actix_utils::timeout::{TimeoutError, TimeoutService};
-use http::Uri;
-use tokio_tcp::TcpStream;
-
-use super::connection::Connection;
-use super::error::ConnectError;
-use super::pool::{ConnectionPool, Protocol};
-use super::Connect;
-
-#[cfg(feature = "ssl")]
-use openssl::ssl::SslConnector as OpensslConnector;
-
-#[cfg(feature = "rust-tls")]
-use rustls::ClientConfig;
-#[cfg(feature = "rust-tls")]
-use std::sync::Arc;
-
-#[cfg(any(feature = "ssl", feature = "rust-tls"))]
-enum SslConnector {
-    #[cfg(feature = "ssl")]
-    Openssl(OpensslConnector),
-    #[cfg(feature = "rust-tls")]
-    Rustls(Arc<ClientConfig>),
-}
-#[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
-type SslConnector = ();
-
-/// Manages http client network connectivity
-/// The `Connector` type uses a builder-like combinator pattern for service
-/// construction that finishes by calling the `.finish()` method.
-///
-/// ```rust,ignore
-/// use std::time::Duration;
-/// use actix_http::client::Connector;
-///
-/// let connector = Connector::new()
-///      .timeout(Duration::from_secs(5))
-///      .finish();
-/// ```
-pub struct Connector<T, U> {
-    connector: T,
-    timeout: Duration,
-    conn_lifetime: Duration,
-    conn_keep_alive: Duration,
-    disconnect_timeout: Duration,
-    limit: usize,
-    #[allow(dead_code)]
-    ssl: SslConnector,
-    _t: PhantomData<U>,
-}
-
-trait Io: AsyncRead + AsyncWrite {}
-impl<T: AsyncRead + AsyncWrite> Io for T {}
-
-impl Connector<(), ()> {
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new() -> Connector<
-        impl Service<
-                Request = TcpConnect<Uri>,
-                Response = TcpConnection<Uri, TcpStream>,
-                Error = actix_connect::ConnectError,
-            > + Clone,
-        TcpStream,
-    > {
-        let ssl = {
-            #[cfg(feature = "ssl")]
-            {
-                use openssl::ssl::SslMethod;
-
-                let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
-                let _ = ssl
-                    .set_alpn_protos(b"\x02h2\x08http/1.1")
-                    .map_err(|e| error!("Can not set alpn protocol: {:?}", e));
-                SslConnector::Openssl(ssl.build())
-            }
-            #[cfg(all(not(feature = "ssl"), feature = "rust-tls"))]
-            {
-                let protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
-                let mut config = ClientConfig::new();
-                config.set_protocols(&protos);
-                config
-                    .root_store
-                    .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS);
-                SslConnector::Rustls(Arc::new(config))
-            }
-            #[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
-            {}
-        };
-
-        Connector {
-            ssl,
-            connector: default_connector(),
-            timeout: Duration::from_secs(1),
-            conn_lifetime: Duration::from_secs(75),
-            conn_keep_alive: Duration::from_secs(15),
-            disconnect_timeout: Duration::from_millis(3000),
-            limit: 100,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, U> Connector<T, U> {
-    /// Use custom connector.
-    pub fn connector<T1, U1>(self, connector: T1) -> Connector<T1, U1>
-    where
-        U1: AsyncRead + AsyncWrite + fmt::Debug,
-        T1: Service<
-                Request = TcpConnect<Uri>,
-                Response = TcpConnection<Uri, U1>,
-                Error = actix_connect::ConnectError,
-            > + Clone,
-    {
-        Connector {
-            connector,
-            timeout: self.timeout,
-            conn_lifetime: self.conn_lifetime,
-            conn_keep_alive: self.conn_keep_alive,
-            disconnect_timeout: self.disconnect_timeout,
-            limit: self.limit,
-            ssl: self.ssl,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, U> Connector<T, U>
-where
-    U: AsyncRead + AsyncWrite + fmt::Debug + 'static,
-    T: Service<
-            Request = TcpConnect<Uri>,
-            Response = TcpConnection<Uri, U>,
-            Error = actix_connect::ConnectError,
-        > + Clone
-        + 'static,
-{
-    /// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
-    /// Set to 1 second by default.
-    pub fn timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = timeout;
-        self
-    }
-
-    #[cfg(feature = "ssl")]
-    /// Use custom `SslConnector` instance.
-    pub fn ssl(mut self, connector: OpensslConnector) -> Self {
-        self.ssl = SslConnector::Openssl(connector);
-        self
-    }
-
-    #[cfg(feature = "rust-tls")]
-    pub fn rustls(mut self, connector: Arc<ClientConfig>) -> Self {
-        self.ssl = SslConnector::Rustls(connector);
-        self
-    }
-
-    /// Set total number of simultaneous connections per type of scheme.
-    ///
-    /// If limit is 0, the connector has no limit.
-    /// The default limit size is 100.
-    pub fn limit(mut self, limit: usize) -> Self {
-        self.limit = limit;
-        self
-    }
-
-    /// Set keep-alive period for opened connection.
-    ///
-    /// Keep-alive period is the period between connection usage. If
-    /// the delay between repeated usages of the same connection
-    /// exceeds this period, the connection is closed.
-    /// Default keep-alive period is 15 seconds.
-    pub fn conn_keep_alive(mut self, dur: Duration) -> Self {
-        self.conn_keep_alive = dur;
-        self
-    }
-
-    /// Set max lifetime period for connection.
-    ///
-    /// Connection lifetime is max lifetime of any opened connection
-    /// until it is closed regardless of keep-alive period.
-    /// Default lifetime period is 75 seconds.
-    pub fn conn_lifetime(mut self, dur: Duration) -> Self {
-        self.conn_lifetime = dur;
-        self
-    }
-
-    /// Set server connection disconnect timeout in milliseconds.
-    ///
-    /// Defines a timeout for disconnect connection. If a disconnect procedure does not complete
-    /// within this time, the socket get dropped. This timeout affects only secure connections.
-    ///
-    /// To disable timeout set value to 0.
-    ///
-    /// By default disconnect timeout is set to 3000 milliseconds.
-    pub fn disconnect_timeout(mut self, dur: Duration) -> Self {
-        self.disconnect_timeout = dur;
-        self
-    }
-
-    /// Finish configuration process and create connector service.
-    /// The Connector builder always concludes by calling `finish()` last in
-    /// its combinator chain.
-    pub fn finish(
-        self,
-    ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
-                 + Clone {
-        #[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
-        {
-            let connector = TimeoutService::new(
-                self.timeout,
-                apply_fn(self.connector, |msg: Connect, srv| {
-                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                })
-                .map_err(ConnectError::from)
-                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
-            )
-            .map_err(|e| match e {
-                TimeoutError::Service(e) => e,
-                TimeoutError::Timeout => ConnectError::Timeout,
-            });
-
-            connect_impl::InnerConnector {
-                tcp_pool: ConnectionPool::new(
-                    connector,
-                    self.conn_lifetime,
-                    self.conn_keep_alive,
-                    None,
-                    self.limit,
-                ),
-            }
-        }
-        #[cfg(any(feature = "ssl", feature = "rust-tls"))]
-        {
-            const H2: &[u8] = b"h2";
-            #[cfg(feature = "ssl")]
-            use actix_connect::ssl::OpensslConnector;
-            #[cfg(feature = "rust-tls")]
-            use actix_connect::ssl::RustlsConnector;
-            use actix_service::boxed::service;
-            #[cfg(feature = "rust-tls")]
-            use rustls::Session;
-
-            let ssl_service = TimeoutService::new(
-                self.timeout,
-                apply_fn(self.connector.clone(), |msg: Connect, srv| {
-                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                })
-                .map_err(ConnectError::from)
-                .and_then(match self.ssl {
-                    #[cfg(feature = "ssl")]
-                    SslConnector::Openssl(ssl) => service(
-                        OpensslConnector::service(ssl)
-                            .map_err(ConnectError::from)
-                            .map(|stream| {
-                                let sock = stream.into_parts().0;
-                                let h2 = sock
-                                    .get_ref()
-                                    .ssl()
-                                    .selected_alpn_protocol()
-                                    .map(|protos| protos.windows(2).any(|w| w == H2))
-                                    .unwrap_or(false);
-                                if h2 {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http2)
-                                } else {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http1)
-                                }
-                            }),
-                    ),
-                    #[cfg(feature = "rust-tls")]
-                    SslConnector::Rustls(ssl) => service(
-                        RustlsConnector::service(ssl)
-                            .map_err(ConnectError::from)
-                            .map(|stream| {
-                                let sock = stream.into_parts().0;
-                                let h2 = sock
-                                    .get_ref()
-                                    .1
-                                    .get_alpn_protocol()
-                                    .map(|protos| protos.windows(2).any(|w| w == H2))
-                                    .unwrap_or(false);
-                                if h2 {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http2)
-                                } else {
-                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http1)
-                                }
-                            }),
-                    ),
-                }),
-            )
-            .map_err(|e| match e {
-                TimeoutError::Service(e) => e,
-                TimeoutError::Timeout => ConnectError::Timeout,
-            });
-
-            let tcp_service = TimeoutService::new(
-                self.timeout,
-                apply_fn(self.connector.clone(), |msg: Connect, srv| {
-                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                })
-                .map_err(ConnectError::from)
-                .map(|stream| (stream.into_parts().0, Protocol::Http1)),
-            )
-            .map_err(|e| match e {
-                TimeoutError::Service(e) => e,
-                TimeoutError::Timeout => ConnectError::Timeout,
-            });
-
-            connect_impl::InnerConnector {
-                tcp_pool: ConnectionPool::new(
-                    tcp_service,
-                    self.conn_lifetime,
-                    self.conn_keep_alive,
-                    None,
-                    self.limit,
-                ),
-                ssl_pool: ConnectionPool::new(
-                    ssl_service,
-                    self.conn_lifetime,
-                    self.conn_keep_alive,
-                    Some(self.disconnect_timeout),
-                    self.limit,
-                ),
-            }
-        }
-    }
-}
-
-#[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
-mod connect_impl {
-    use futures::future::{err, Either, FutureResult};
-    use futures::Poll;
-
-    use super::*;
-    use crate::client::connection::IoConnection;
-
-    pub(crate) struct InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-    {
-        pub(crate) tcp_pool: ConnectionPool<T, Io>,
-    }
-
-    impl<T, Io> Clone for InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-    {
-        fn clone(&self) -> Self {
-            InnerConnector {
-                tcp_pool: self.tcp_pool.clone(),
-            }
-        }
-    }
-
-    impl<T, Io> Service for InnerConnector<T, Io>
-    where
-        Io: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-    {
-        type Request = Connect;
-        type Response = IoConnection<Io>;
-        type Error = ConnectError;
-        type Future = Either<
-            <ConnectionPool<T, Io> as Service>::Future,
-            FutureResult<IoConnection<Io>, ConnectError>,
-        >;
-
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            self.tcp_pool.poll_ready()
-        }
-
-        fn call(&mut self, req: Connect) -> Self::Future {
-            match req.uri.scheme_str() {
-                Some("https") | Some("wss") => {
-                    Either::B(err(ConnectError::SslIsNotSupported))
-                }
-                _ => Either::A(self.tcp_pool.call(req)),
-            }
-        }
-    }
-}
-
-#[cfg(any(feature = "ssl", feature = "rust-tls"))]
-mod connect_impl {
-    use std::marker::PhantomData;
-
-    use futures::future::{Either, FutureResult};
-    use futures::{Async, Future, Poll};
-
-    use super::*;
-    use crate::client::connection::EitherConnection;
-
-    pub(crate) struct InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + 'static,
-        Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>,
-    {
-        pub(crate) tcp_pool: ConnectionPool<T1, Io1>,
-        pub(crate) ssl_pool: ConnectionPool<T2, Io2>,
-    }
-
-    impl<T1, T2, Io1, Io2> Clone for InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + 'static,
-        Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-    {
-        fn clone(&self) -> Self {
-            InnerConnector {
-                tcp_pool: self.tcp_pool.clone(),
-                ssl_pool: self.ssl_pool.clone(),
-            }
-        }
-    }
-
-    impl<T1, T2, Io1, Io2> Service for InnerConnector<T1, T2, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + 'static,
-        Io2: AsyncRead + AsyncWrite + 'static,
-        T1: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-        T2: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-    {
-        type Request = Connect;
-        type Response = EitherConnection<Io1, Io2>;
-        type Error = ConnectError;
-        type Future = Either<
-            FutureResult<Self::Response, Self::Error>,
-            Either<
-                InnerConnectorResponseA<T1, Io1, Io2>,
-                InnerConnectorResponseB<T2, Io1, Io2>,
-            >,
-        >;
-
-        fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-            self.tcp_pool.poll_ready()
-        }
-
-        fn call(&mut self, req: Connect) -> Self::Future {
-            match req.uri.scheme_str() {
-                Some("https") | Some("wss") => {
-                    Either::B(Either::B(InnerConnectorResponseB {
-                        fut: self.ssl_pool.call(req),
-                        _t: PhantomData,
-                    }))
-                }
-                _ => Either::B(Either::A(InnerConnectorResponseA {
-                    fut: self.tcp_pool.call(req),
-                    _t: PhantomData,
-                })),
-            }
-        }
-    }
-
-    pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
-    where
-        Io1: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-    {
-        fut: <ConnectionPool<T, Io1> as Service>::Future,
-        _t: PhantomData<Io2>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseA<T, Io1, Io2>
-    where
-        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-        Io1: AsyncRead + AsyncWrite + 'static,
-        Io2: AsyncRead + AsyncWrite + 'static,
-    {
-        type Item = EitherConnection<Io1, Io2>;
-        type Error = ConnectError;
-
-        fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-            match self.fut.poll()? {
-                Async::NotReady => Ok(Async::NotReady),
-                Async::Ready(res) => Ok(Async::Ready(EitherConnection::A(res))),
-            }
-        }
-    }
-
-    pub(crate) struct InnerConnectorResponseB<T, Io1, Io2>
-    where
-        Io2: AsyncRead + AsyncWrite + 'static,
-        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-    {
-        fut: <ConnectionPool<T, Io2> as Service>::Future,
-        _t: PhantomData<Io1>,
-    }
-
-    impl<T, Io1, Io2> Future for InnerConnectorResponseB<T, Io1, Io2>
-    where
-        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
-            + Clone
-            + 'static,
-        Io1: AsyncRead + AsyncWrite + 'static,
-        Io2: AsyncRead + AsyncWrite + 'static,
-    {
-        type Item = EitherConnection<Io1, Io2>;
-        type Error = ConnectError;
-
-        fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-            match self.fut.poll()? {
-                Async::NotReady => Ok(Async::NotReady),
-                Async::Ready(res) => Ok(Async::Ready(EitherConnection::B(res))),
-            }
-        }
-    }
-}
--- a/actix-http/src/client/error.rs
+++ b/actix-http/src/client/error.rs
@@ -1,150 +0,0 @@
-use std::io;
-
-use derive_more::{Display, From};
-use trust_dns_resolver::error::ResolveError;
-
-#[cfg(feature = "ssl")]
-use openssl::ssl::{Error as SslError, HandshakeError};
-
-use crate::error::{Error, ParseError, ResponseError};
-use crate::http::Error as HttpError;
-use crate::response::Response;
-
-/// A set of errors that can occur while connecting to an HTTP host
-#[derive(Debug, Display, From)]
-pub enum ConnectError {
-    /// SSL feature is not enabled
-    #[display(fmt = "SSL is not supported")]
-    SslIsNotSupported,
-
-    /// SSL error
-    #[cfg(feature = "ssl")]
-    #[display(fmt = "{}", _0)]
-    SslError(SslError),
-
-    /// Failed to resolve the hostname
-    #[display(fmt = "Failed resolving hostname: {}", _0)]
-    Resolver(ResolveError),
-
-    /// No dns records
-    #[display(fmt = "No dns records found for the input")]
-    NoRecords,
-
-    /// Http2 error
-    #[display(fmt = "{}", _0)]
-    H2(h2::Error),
-
-    /// Connecting took too long
-    #[display(fmt = "Timeout out while establishing connection")]
-    Timeout,
-
-    /// Connector has been disconnected
-    #[display(fmt = "Internal error: connector has been disconnected")]
-    Disconnected,
-
-    /// Unresolved host name
-    #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolverd,
-
-    /// Connection io error
-    #[display(fmt = "{}", _0)]
-    Io(io::Error),
-}
-
-impl From<actix_connect::ConnectError> for ConnectError {
-    fn from(err: actix_connect::ConnectError) -> ConnectError {
-        match err {
-            actix_connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
-            actix_connect::ConnectError::NoRecords => ConnectError::NoRecords,
-            actix_connect::ConnectError::InvalidInput => panic!(),
-            actix_connect::ConnectError::Unresolverd => ConnectError::Unresolverd,
-            actix_connect::ConnectError::Io(e) => ConnectError::Io(e),
-        }
-    }
-}
-
-#[cfg(feature = "ssl")]
-impl<T> From<HandshakeError<T>> for ConnectError {
-    fn from(err: HandshakeError<T>) -> ConnectError {
-        match err {
-            HandshakeError::SetupFailure(stack) => SslError::from(stack).into(),
-            HandshakeError::Failure(stream) => stream.into_error().into(),
-            HandshakeError::WouldBlock(stream) => stream.into_error().into(),
-        }
-    }
-}
-
-#[derive(Debug, Display, From)]
-pub enum InvalidUrl {
-    #[display(fmt = "Missing url scheme")]
-    MissingScheme,
-    #[display(fmt = "Unknown url scheme")]
-    UnknownScheme,
-    #[display(fmt = "Missing host name")]
-    MissingHost,
-    #[display(fmt = "Url parse error: {}", _0)]
-    HttpError(http::Error),
-}
-
-/// A set of errors that can occur during request sending and response reading
-#[derive(Debug, Display, From)]
-pub enum SendRequestError {
-    /// Invalid URL
-    #[display(fmt = "Invalid URL: {}", _0)]
-    Url(InvalidUrl),
-    /// Failed to connect to host
-    #[display(fmt = "Failed to connect to host: {}", _0)]
-    Connect(ConnectError),
-    /// Error sending request
-    Send(io::Error),
-    /// Error parsing response
-    Response(ParseError),
-    /// Http error
-    #[display(fmt = "{}", _0)]
-    Http(HttpError),
-    /// Http2 error
-    #[display(fmt = "{}", _0)]
-    H2(h2::Error),
-    /// Response took too long
-    #[display(fmt = "Timeout out while waiting for response")]
-    Timeout,
-    /// Tunnels are not supported for http2 connection
-    #[display(fmt = "Tunnels are not supported for http2 connection")]
-    TunnelNotSupported,
-    /// Error sending request body
-    Body(Error),
-}
-
-/// Convert `SendRequestError` to a server `Response`
-impl ResponseError for SendRequestError {
-    fn error_response(&self) -> Response {
-        match *self {
-            SendRequestError::Connect(ConnectError::Timeout) => {
-                Response::GatewayTimeout()
-            }
-            SendRequestError::Connect(_) => Response::BadGateway(),
-            _ => Response::InternalServerError(),
-        }
-        .into()
-    }
-}
-
-/// A set of errors that can occur during freezing a request
-#[derive(Debug, Display, From)]
-pub enum FreezeRequestError {
-    /// Invalid URL
-    #[display(fmt = "Invalid URL: {}", _0)]
-    Url(InvalidUrl),
-    /// Http error
-    #[display(fmt = "{}", _0)]
-    Http(HttpError),
-}
-
-impl From<FreezeRequestError> for SendRequestError {
-    fn from(e: FreezeRequestError) -> Self {
-        match e {
-            FreezeRequestError::Url(e) => e.into(),
-            FreezeRequestError::Http(e) => e.into(),
-        }
-    }
-}
--- a/actix-http/src/client/h1proto.rs
+++ b/actix-http/src/client/h1proto.rs
@@ -1,304 +0,0 @@
-use std::io::Write;
-use std::{io, time};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use bytes::{BufMut, Bytes, BytesMut};
-use futures::future::{ok, Either};
-use futures::{Async, Future, Poll, Sink, Stream};
-
-use crate::error::PayloadError;
-use crate::h1;
-use crate::header::HeaderMap;
-use crate::http::header::{IntoHeaderValue, HOST};
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::{Payload, PayloadStream};
-
-use super::connection::{ConnectionLifetime, ConnectionType, IoConnection};
-use super::error::{ConnectError, SendRequestError};
-use super::pool::Acquired;
-use crate::body::{BodySize, MessageBody};
-
-pub(crate) fn send_request<T, B>(
-    io: T,
-    mut head: RequestHeadType,
-    body: B,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-) -> impl Future<Item = (ResponseHead, Payload), Error = SendRequestError>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    B: MessageBody,
-{
-    // set request host header
-    if !head.as_ref().headers.contains_key(HOST)
-        && !head.extra_headers().iter().any(|h| h.contains_key(HOST))
-    {
-        if let Some(host) = head.as_ref().uri.host() {
-            let mut wrt = BytesMut::with_capacity(host.len() + 5).writer();
-
-            let _ = match head.as_ref().uri.port_u16() {
-                None | Some(80) | Some(443) => write!(wrt, "{}", host),
-                Some(port) => write!(wrt, "{}:{}", host, port),
-            };
-
-            match wrt.get_mut().take().freeze().try_into() {
-                Ok(value) => match head {
-                    RequestHeadType::Owned(ref mut head) => {
-                        head.headers.insert(HOST, value)
-                    }
-                    RequestHeadType::Rc(_, ref mut extra_headers) => {
-                        let headers = extra_headers.get_or_insert(HeaderMap::new());
-                        headers.insert(HOST, value)
-                    }
-                },
-                Err(e) => log::error!("Can not set HOST header {}", e),
-            }
-        }
-    }
-
-    let io = H1Connection {
-        created,
-        pool,
-        io: Some(io),
-    };
-
-    let len = body.size();
-
-    // create Framed and send request
-    Framed::new(io, h1::ClientCodec::default())
-        .send((head, len).into())
-        .from_err()
-        // send request body
-        .and_then(move |framed| match body.size() {
-            BodySize::None | BodySize::Empty | BodySize::Sized(0) => {
-                Either::A(ok(framed))
-            }
-            _ => Either::B(SendBody::new(body, framed)),
-        })
-        // read response and init read body
-        .and_then(|framed| {
-            framed
-                .into_future()
-                .map_err(|(e, _)| SendRequestError::from(e))
-                .and_then(|(item, framed)| {
-                    if let Some(res) = item {
-                        match framed.get_codec().message_type() {
-                            h1::MessageType::None => {
-                                let force_close = !framed.get_codec().keepalive();
-                                release_connection(framed, force_close);
-                                Ok((res, Payload::None))
-                            }
-                            _ => {
-                                let pl: PayloadStream = Box::new(PlStream::new(framed));
-                                Ok((res, pl.into()))
-                            }
-                        }
-                    } else {
-                        Err(ConnectError::Disconnected.into())
-                    }
-                })
-        })
-}
-
-pub(crate) fn open_tunnel<T>(
-    io: T,
-    head: RequestHeadType,
-) -> impl Future<Item = (ResponseHead, Framed<T, h1::ClientCodec>), Error = SendRequestError>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-{
-    // create Framed and send request
-    Framed::new(io, h1::ClientCodec::default())
-        .send((head, BodySize::None).into())
-        .from_err()
-        // read response
-        .and_then(|framed| {
-            framed
-                .into_future()
-                .map_err(|(e, _)| SendRequestError::from(e))
-                .and_then(|(head, framed)| {
-                    if let Some(head) = head {
-                        Ok((head, framed))
-                    } else {
-                        Err(SendRequestError::from(ConnectError::Disconnected))
-                    }
-                })
-        })
-}
-
-#[doc(hidden)]
-/// HTTP client connection
-pub struct H1Connection<T> {
-    io: Option<T>,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-}
-
-impl<T: AsyncRead + AsyncWrite + 'static> ConnectionLifetime for H1Connection<T> {
-    /// Close connection
-    fn close(&mut self) {
-        if let Some(mut pool) = self.pool.take() {
-            if let Some(io) = self.io.take() {
-                pool.close(IoConnection::new(
-                    ConnectionType::H1(io),
-                    self.created,
-                    None,
-                ));
-            }
-        }
-    }
-
-    /// Release this connection to the connection pool
-    fn release(&mut self) {
-        if let Some(mut pool) = self.pool.take() {
-            if let Some(io) = self.io.take() {
-                pool.release(IoConnection::new(
-                    ConnectionType::H1(io),
-                    self.created,
-                    None,
-                ));
-            }
-        }
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + 'static> io::Read for H1Connection<T> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.io.as_mut().unwrap().read(buf)
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + 'static> AsyncRead for H1Connection<T> {}
-
-impl<T: AsyncRead + AsyncWrite + 'static> io::Write for H1Connection<T> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.io.as_mut().unwrap().write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        self.io.as_mut().unwrap().flush()
-    }
-}
-
-impl<T: AsyncRead + AsyncWrite + 'static> AsyncWrite for H1Connection<T> {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        self.io.as_mut().unwrap().shutdown()
-    }
-}
-
-/// Future responsible for sending request body to the peer
-pub(crate) struct SendBody<I, B> {
-    body: Option<B>,
-    framed: Option<Framed<I, h1::ClientCodec>>,
-    flushed: bool,
-}
-
-impl<I, B> SendBody<I, B>
-where
-    I: AsyncRead + AsyncWrite + 'static,
-    B: MessageBody,
-{
-    pub(crate) fn new(body: B, framed: Framed<I, h1::ClientCodec>) -> Self {
-        SendBody {
-            body: Some(body),
-            framed: Some(framed),
-            flushed: true,
-        }
-    }
-}
-
-impl<I, B> Future for SendBody<I, B>
-where
-    I: ConnectionLifetime,
-    B: MessageBody,
-{
-    type Item = Framed<I, h1::ClientCodec>;
-    type Error = SendRequestError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let mut body_ready = true;
-        loop {
-            while body_ready
-                && self.body.is_some()
-                && !self.framed.as_ref().unwrap().is_write_buf_full()
-            {
-                match self.body.as_mut().unwrap().poll_next()? {
-                    Async::Ready(item) => {
-                        // check if body is done
-                        if item.is_none() {
-                            let _ = self.body.take();
-                        }
-                        self.flushed = false;
-                        self.framed
-                            .as_mut()
-                            .unwrap()
-                            .force_send(h1::Message::Chunk(item))?;
-                        break;
-                    }
-                    Async::NotReady => body_ready = false,
-                }
-            }
-
-            if !self.flushed {
-                match self.framed.as_mut().unwrap().poll_complete()? {
-                    Async::Ready(_) => {
-                        self.flushed = true;
-                        continue;
-                    }
-                    Async::NotReady => return Ok(Async::NotReady),
-                }
-            }
-
-            if self.body.is_none() {
-                return Ok(Async::Ready(self.framed.take().unwrap()));
-            }
-            return Ok(Async::NotReady);
-        }
-    }
-}
-
-pub(crate) struct PlStream<Io> {
-    framed: Option<Framed<Io, h1::ClientPayloadCodec>>,
-}
-
-impl<Io: ConnectionLifetime> PlStream<Io> {
-    fn new(framed: Framed<Io, h1::ClientCodec>) -> Self {
-        PlStream {
-            framed: Some(framed.map_codec(|codec| codec.into_payload_codec())),
-        }
-    }
-}
-
-impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
-    type Item = Bytes;
-    type Error = PayloadError;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        match self.framed.as_mut().unwrap().poll()? {
-            Async::NotReady => Ok(Async::NotReady),
-            Async::Ready(Some(chunk)) => {
-                if let Some(chunk) = chunk {
-                    Ok(Async::Ready(Some(chunk)))
-                } else {
-                    let framed = self.framed.take().unwrap();
-                    let force_close = !framed.get_codec().keepalive();
-                    release_connection(framed, force_close);
-                    Ok(Async::Ready(None))
-                }
-            }
-            Async::Ready(None) => Ok(Async::Ready(None)),
-        }
-    }
-}
-
-fn release_connection<T, U>(framed: Framed<T, U>, force_close: bool)
-where
-    T: ConnectionLifetime,
-{
-    let mut parts = framed.into_parts();
-    if !force_close && parts.read_buf.is_empty() && parts.write_buf.is_empty() {
-        parts.io.release()
-    } else {
-        parts.io.close()
-    }
-}
--- a/actix-http/src/client/h2proto.rs
+++ b/actix-http/src/client/h2proto.rs
@@ -1,203 +0,0 @@
-use std::time;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use bytes::Bytes;
-use futures::future::{err, Either};
-use futures::{Async, Future, Poll};
-use h2::{client::SendRequest, SendStream};
-use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
-use http::{request::Request, HttpTryFrom, Method, Version};
-
-use crate::body::{BodySize, MessageBody};
-use crate::header::HeaderMap;
-use crate::message::{RequestHeadType, ResponseHead};
-use crate::payload::Payload;
-
-use super::connection::{ConnectionType, IoConnection};
-use super::error::SendRequestError;
-use super::pool::Acquired;
-
-pub(crate) fn send_request<T, B>(
-    io: SendRequest<Bytes>,
-    head: RequestHeadType,
-    body: B,
-    created: time::Instant,
-    pool: Option<Acquired<T>>,
-) -> impl Future<Item = (ResponseHead, Payload), Error = SendRequestError>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-    B: MessageBody,
-{
-    trace!("Sending client request: {:?} {:?}", head, body.size());
-    let head_req = head.as_ref().method == Method::HEAD;
-    let length = body.size();
-    let eof = match length {
-        BodySize::None | BodySize::Empty | BodySize::Sized(0) => true,
-        _ => false,
-    };
-
-    io.ready()
-        .map_err(SendRequestError::from)
-        .and_then(move |mut io| {
-            let mut req = Request::new(());
-            *req.uri_mut() = head.as_ref().uri.clone();
-            *req.method_mut() = head.as_ref().method.clone();
-            *req.version_mut() = Version::HTTP_2;
-
-            let mut skip_len = true;
-            // let mut has_date = false;
-
-            // Content length
-            let _ = match length {
-                BodySize::None => None,
-                BodySize::Stream => {
-                    skip_len = false;
-                    None
-                }
-                BodySize::Empty => req
-                    .headers_mut()
-                    .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-                BodySize::Sized(len) => req.headers_mut().insert(
-                    CONTENT_LENGTH,
-                    HeaderValue::try_from(format!("{}", len)).unwrap(),
-                ),
-                BodySize::Sized64(len) => req.headers_mut().insert(
-                    CONTENT_LENGTH,
-                    HeaderValue::try_from(format!("{}", len)).unwrap(),
-                ),
-            };
-
-            // Extracting extra headers from RequestHeadType. HeaderMap::new() does not allocate.
-            let (head, extra_headers) = match head {
-                RequestHeadType::Owned(head) => {
-                    (RequestHeadType::Owned(head), HeaderMap::new())
-                }
-                RequestHeadType::Rc(head, extra_headers) => (
-                    RequestHeadType::Rc(head, None),
-                    extra_headers.unwrap_or_else(HeaderMap::new),
-                ),
-            };
-
-            // merging headers from head and extra headers.
-            let headers = head
-                .as_ref()
-                .headers
-                .iter()
-                .filter(|(name, _)| !extra_headers.contains_key(*name))
-                .chain(extra_headers.iter());
-
-            // copy headers
-            for (key, value) in headers {
-                match *key {
-                    CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
-                    CONTENT_LENGTH if skip_len => continue,
-                    // DATE => has_date = true,
-                    _ => (),
-                }
-                req.headers_mut().append(key, value.clone());
-            }
-
-            match io.send_request(req, eof) {
-                Ok((res, send)) => {
-                    release(io, pool, created, false);
-
-                    if !eof {
-                        Either::A(Either::B(
-                            SendBody {
-                                body,
-                                send,
-                                buf: None,
-                            }
-                            .and_then(move |_| res.map_err(SendRequestError::from)),
-                        ))
-                    } else {
-                        Either::B(res.map_err(SendRequestError::from))
-                    }
-                }
-                Err(e) => {
-                    release(io, pool, created, e.is_io());
-                    Either::A(Either::A(err(e.into())))
-                }
-            }
-        })
-        .and_then(move |resp| {
-            let (parts, body) = resp.into_parts();
-            let payload = if head_req { Payload::None } else { body.into() };
-
-            let mut head = ResponseHead::new(parts.status);
-            head.version = parts.version;
-            head.headers = parts.headers.into();
-            Ok((head, payload))
-        })
-        .from_err()
-}
-
-struct SendBody<B: MessageBody> {
-    body: B,
-    send: SendStream<Bytes>,
-    buf: Option<Bytes>,
-}
-
-impl<B: MessageBody> Future for SendBody<B> {
-    type Item = ();
-    type Error = SendRequestError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            if self.buf.is_none() {
-                match self.body.poll_next() {
-                    Ok(Async::Ready(Some(buf))) => {
-                        self.send.reserve_capacity(buf.len());
-                        self.buf = Some(buf);
-                    }
-                    Ok(Async::Ready(None)) => {
-                        if let Err(e) = self.send.send_data(Bytes::new(), true) {
-                            return Err(e.into());
-                        }
-                        self.send.reserve_capacity(0);
-                        return Ok(Async::Ready(()));
-                    }
-                    Ok(Async::NotReady) => return Ok(Async::NotReady),
-                    Err(e) => return Err(e.into()),
-                }
-            }
-
-            match self.send.poll_capacity() {
-                Ok(Async::NotReady) => return Ok(Async::NotReady),
-                Ok(Async::Ready(None)) => return Ok(Async::Ready(())),
-                Ok(Async::Ready(Some(cap))) => {
-                    let mut buf = self.buf.take().unwrap();
-                    let len = buf.len();
-                    let bytes = buf.split_to(std::cmp::min(cap, len));
-
-                    if let Err(e) = self.send.send_data(bytes, false) {
-                        return Err(e.into());
-                    } else {
-                        if !buf.is_empty() {
-                            self.send.reserve_capacity(buf.len());
-                            self.buf = Some(buf);
-                        }
-                        continue;
-                    }
-                }
-                Err(e) => return Err(e.into()),
-            }
-        }
-    }
-}
-
-// release SendRequest object
-fn release<T: AsyncRead + AsyncWrite + 'static>(
-    io: SendRequest<Bytes>,
-    pool: Option<Acquired<T>>,
-    created: time::Instant,
-    close: bool,
-) {
-    if let Some(mut pool) = pool {
-        if close {
-            pool.close(IoConnection::new(ConnectionType::H2(io), created, None));
-        } else {
-            pool.release(IoConnection::new(ConnectionType::H2(io), created, None));
-        }
-    }
-}
--- a/actix-http/src/client/mod.rs
+++ b/actix-http/src/client/mod.rs
@@ -1,20 +0,0 @@
-//! Http client api
-use http::Uri;
-
-mod connection;
-mod connector;
-mod error;
-mod h1proto;
-mod h2proto;
-mod pool;
-
-pub use self::connection::Connection;
-pub use self::connector::Connector;
-pub use self::error::{ConnectError, FreezeRequestError, InvalidUrl, SendRequestError};
-pub use self::pool::Protocol;
-
-#[derive(Clone)]
-pub struct Connect {
-    pub uri: Uri,
-    pub addr: Option<std::net::SocketAddr>,
-}
--- a/actix-http/src/client/pool.rs
+++ b/actix-http/src/client/pool.rs
@@ -1,672 +0,0 @@
-use std::cell::RefCell;
-use std::collections::VecDeque;
-use std::io;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_service::Service;
-use bytes::Bytes;
-use futures::future::{err, ok, Either, FutureResult};
-use futures::task::AtomicTask;
-use futures::unsync::oneshot;
-use futures::{Async, Future, Poll};
-use h2::client::{handshake, Handshake};
-use hashbrown::HashMap;
-use http::uri::Authority;
-use indexmap::IndexSet;
-use slab::Slab;
-use tokio_timer::{sleep, Delay};
-
-use super::connection::{ConnectionType, IoConnection};
-use super::error::ConnectError;
-use super::Connect;
-
-#[derive(Clone, Copy, PartialEq)]
-/// Protocol version
-pub enum Protocol {
-    Http1,
-    Http2,
-}
-
-#[derive(Hash, Eq, PartialEq, Clone, Debug)]
-pub(crate) struct Key {
-    authority: Authority,
-}
-
-impl From<Authority> for Key {
-    fn from(authority: Authority) -> Key {
-        Key { authority }
-    }
-}
-
-/// Connections pool
-pub(crate) struct ConnectionPool<T, Io: AsyncRead + AsyncWrite + 'static>(
-    T,
-    Rc<RefCell<Inner<Io>>>,
-);
-
-impl<T, Io> ConnectionPool<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-{
-    pub(crate) fn new(
-        connector: T,
-        conn_lifetime: Duration,
-        conn_keep_alive: Duration,
-        disconnect_timeout: Option<Duration>,
-        limit: usize,
-    ) -> Self {
-        ConnectionPool(
-            connector,
-            Rc::new(RefCell::new(Inner {
-                conn_lifetime,
-                conn_keep_alive,
-                disconnect_timeout,
-                limit,
-                acquired: 0,
-                waiters: Slab::new(),
-                waiters_queue: IndexSet::new(),
-                available: HashMap::new(),
-                task: None,
-            })),
-        )
-    }
-}
-
-impl<T, Io> Clone for ConnectionPool<T, Io>
-where
-    T: Clone,
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fn clone(&self) -> Self {
-        ConnectionPool(self.0.clone(), self.1.clone())
-    }
-}
-
-impl<T, Io> Service for ConnectionPool<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
-        + Clone
-        + 'static,
-{
-    type Request = Connect;
-    type Response = IoConnection<Io>;
-    type Error = ConnectError;
-    type Future = Either<
-        FutureResult<Self::Response, Self::Error>,
-        Either<WaitForConnection<Io>, OpenConnection<T::Future, Io>>,
-    >;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.0.poll_ready()
-    }
-
-    fn call(&mut self, req: Connect) -> Self::Future {
-        let key = if let Some(authority) = req.uri.authority_part() {
-            authority.clone().into()
-        } else {
-            return Either::A(err(ConnectError::Unresolverd));
-        };
-
-        // acquire connection
-        match self.1.as_ref().borrow_mut().acquire(&key) {
-            Acquire::Acquired(io, created) => {
-                // use existing connection
-                return Either::A(ok(IoConnection::new(
-                    io,
-                    created,
-                    Some(Acquired(key, Some(self.1.clone()))),
-                )));
-            }
-            Acquire::Available => {
-                // open new connection
-                return Either::B(Either::B(OpenConnection::new(
-                    key,
-                    self.1.clone(),
-                    self.0.call(req),
-                )));
-            }
-            _ => (),
-        }
-
-        // connection is not available, wait
-        let (rx, token, support) = self.1.as_ref().borrow_mut().wait_for(req);
-
-        // start support future
-        if !support {
-            self.1.as_ref().borrow_mut().task = Some(AtomicTask::new());
-            tokio_current_thread::spawn(ConnectorPoolSupport {
-                connector: self.0.clone(),
-                inner: self.1.clone(),
-            })
-        }
-
-        Either::B(Either::A(WaitForConnection {
-            rx,
-            key,
-            token,
-            inner: Some(self.1.clone()),
-        }))
-    }
-}
-
-#[doc(hidden)]
-pub struct WaitForConnection<Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    key: Key,
-    token: usize,
-    rx: oneshot::Receiver<Result<IoConnection<Io>, ConnectError>>,
-    inner: Option<Rc<RefCell<Inner<Io>>>>,
-}
-
-impl<Io> Drop for WaitForConnection<Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fn drop(&mut self) {
-        if let Some(i) = self.inner.take() {
-            let mut inner = i.as_ref().borrow_mut();
-            inner.release_waiter(&self.key, self.token);
-            inner.check_availibility();
-        }
-    }
-}
-
-impl<Io> Future for WaitForConnection<Io>
-where
-    Io: AsyncRead + AsyncWrite,
-{
-    type Item = IoConnection<Io>;
-    type Error = ConnectError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.rx.poll() {
-            Ok(Async::Ready(item)) => match item {
-                Err(err) => Err(err),
-                Ok(conn) => {
-                    let _ = self.inner.take();
-                    Ok(Async::Ready(conn))
-                }
-            },
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(_) => {
-                let _ = self.inner.take();
-                Err(ConnectError::Disconnected)
-            }
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct OpenConnection<F, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fut: F,
-    key: Key,
-    h2: Option<Handshake<Io, Bytes>>,
-    inner: Option<Rc<RefCell<Inner<Io>>>>,
-}
-
-impl<F, Io> OpenConnection<F, Io>
-where
-    F: Future<Item = (Io, Protocol), Error = ConnectError>,
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fn new(key: Key, inner: Rc<RefCell<Inner<Io>>>, fut: F) -> Self {
-        OpenConnection {
-            key,
-            fut,
-            inner: Some(inner),
-            h2: None,
-        }
-    }
-}
-
-impl<F, Io> Drop for OpenConnection<F, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fn drop(&mut self) {
-        if let Some(inner) = self.inner.take() {
-            let mut inner = inner.as_ref().borrow_mut();
-            inner.release();
-            inner.check_availibility();
-        }
-    }
-}
-
-impl<F, Io> Future for OpenConnection<F, Io>
-where
-    F: Future<Item = (Io, Protocol), Error = ConnectError>,
-    Io: AsyncRead + AsyncWrite,
-{
-    type Item = IoConnection<Io>;
-    type Error = ConnectError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut h2) = self.h2 {
-            return match h2.poll() {
-                Ok(Async::Ready((snd, connection))) => {
-                    tokio_current_thread::spawn(connection.map_err(|_| ()));
-                    Ok(Async::Ready(IoConnection::new(
-                        ConnectionType::H2(snd),
-                        Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.take())),
-                    )))
-                }
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-                Err(e) => Err(e.into()),
-            };
-        }
-
-        match self.fut.poll() {
-            Err(err) => Err(err),
-            Ok(Async::Ready((io, proto))) => {
-                if proto == Protocol::Http1 {
-                    Ok(Async::Ready(IoConnection::new(
-                        ConnectionType::H1(io),
-                        Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.take())),
-                    )))
-                } else {
-                    self.h2 = Some(handshake(io));
-                    self.poll()
-                }
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-        }
-    }
-}
-
-enum Acquire<T> {
-    Acquired(ConnectionType<T>, Instant),
-    Available,
-    NotAvailable,
-}
-
-struct AvailableConnection<Io> {
-    io: ConnectionType<Io>,
-    used: Instant,
-    created: Instant,
-}
-
-pub(crate) struct Inner<Io> {
-    conn_lifetime: Duration,
-    conn_keep_alive: Duration,
-    disconnect_timeout: Option<Duration>,
-    limit: usize,
-    acquired: usize,
-    available: HashMap<Key, VecDeque<AvailableConnection<Io>>>,
-    waiters: Slab<
-        Option<(
-            Connect,
-            oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
-        )>,
-    >,
-    waiters_queue: IndexSet<(Key, usize)>,
-    task: Option<AtomicTask>,
-}
-
-impl<Io> Inner<Io> {
-    fn reserve(&mut self) {
-        self.acquired += 1;
-    }
-
-    fn release(&mut self) {
-        self.acquired -= 1;
-    }
-
-    fn release_waiter(&mut self, key: &Key, token: usize) {
-        self.waiters.remove(token);
-        let _ = self.waiters_queue.shift_remove(&(key.clone(), token));
-    }
-}
-
-impl<Io> Inner<Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    /// connection is not available, wait
-    fn wait_for(
-        &mut self,
-        connect: Connect,
-    ) -> (
-        oneshot::Receiver<Result<IoConnection<Io>, ConnectError>>,
-        usize,
-        bool,
-    ) {
-        let (tx, rx) = oneshot::channel();
-
-        let key: Key = connect.uri.authority_part().unwrap().clone().into();
-        let entry = self.waiters.vacant_entry();
-        let token = entry.key();
-        entry.insert(Some((connect, tx)));
-        assert!(self.waiters_queue.insert((key, token)));
-
-        (rx, token, self.task.is_some())
-    }
-
-    fn acquire(&mut self, key: &Key) -> Acquire<Io> {
-        // check limits
-        if self.limit > 0 && self.acquired >= self.limit {
-            return Acquire::NotAvailable;
-        }
-
-        self.reserve();
-
-        // check if open connection is available
-        // cleanup stale connections at the same time
-        if let Some(ref mut connections) = self.available.get_mut(key) {
-            let now = Instant::now();
-            while let Some(conn) = connections.pop_back() {
-                // check if it still usable
-                if (now - conn.used) > self.conn_keep_alive
-                    || (now - conn.created) > self.conn_lifetime
-                {
-                    if let Some(timeout) = self.disconnect_timeout {
-                        if let ConnectionType::H1(io) = conn.io {
-                            tokio_current_thread::spawn(CloseConnection::new(
-                                io, timeout,
-                            ))
-                        }
-                    }
-                } else {
-                    let mut io = conn.io;
-                    let mut buf = [0; 2];
-                    if let ConnectionType::H1(ref mut s) = io {
-                        match s.read(&mut buf) {
-                            Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => (),
-                            Ok(n) if n > 0 => {
-                                if let Some(timeout) = self.disconnect_timeout {
-                                    if let ConnectionType::H1(io) = io {
-                                        tokio_current_thread::spawn(
-                                            CloseConnection::new(io, timeout),
-                                        )
-                                    }
-                                }
-                                continue;
-                            }
-                            Ok(_) | Err(_) => continue,
-                        }
-                    }
-                    return Acquire::Acquired(io, conn.created);
-                }
-            }
-        }
-        Acquire::Available
-    }
-
-    fn release_conn(&mut self, key: &Key, io: ConnectionType<Io>, created: Instant) {
-        self.acquired -= 1;
-        self.available
-            .entry(key.clone())
-            .or_insert_with(VecDeque::new)
-            .push_back(AvailableConnection {
-                io,
-                created,
-                used: Instant::now(),
-            });
-        self.check_availibility();
-    }
-
-    fn release_close(&mut self, io: ConnectionType<Io>) {
-        self.acquired -= 1;
-        if let Some(timeout) = self.disconnect_timeout {
-            if let ConnectionType::H1(io) = io {
-                tokio_current_thread::spawn(CloseConnection::new(io, timeout))
-            }
-        }
-        self.check_availibility();
-    }
-
-    fn check_availibility(&self) {
-        if !self.waiters_queue.is_empty() && self.acquired < self.limit {
-            if let Some(t) = self.task.as_ref() {
-                t.notify()
-            }
-        }
-    }
-}
-
-struct CloseConnection<T> {
-    io: T,
-    timeout: Delay,
-}
-
-impl<T> CloseConnection<T>
-where
-    T: AsyncWrite,
-{
-    fn new(io: T, timeout: Duration) -> Self {
-        CloseConnection {
-            io,
-            timeout: sleep(timeout),
-        }
-    }
-}
-
-impl<T> Future for CloseConnection<T>
-where
-    T: AsyncWrite,
-{
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<(), ()> {
-        match self.timeout.poll() {
-            Ok(Async::Ready(_)) | Err(_) => Ok(Async::Ready(())),
-            Ok(Async::NotReady) => match self.io.shutdown() {
-                Ok(Async::Ready(_)) | Err(_) => Ok(Async::Ready(())),
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-            },
-        }
-    }
-}
-
-struct ConnectorPoolSupport<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    connector: T,
-    inner: Rc<RefCell<Inner<Io>>>,
-}
-
-impl<T, Io> Future for ConnectorPoolSupport<T, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>,
-    T::Future: 'static,
-{
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let mut inner = self.inner.as_ref().borrow_mut();
-        inner.task.as_ref().unwrap().register();
-
-        // check waiters
-        loop {
-            let (key, token) = {
-                if let Some((key, token)) = inner.waiters_queue.get_index(0) {
-                    (key.clone(), *token)
-                } else {
-                    break;
-                }
-            };
-            if inner.waiters.get(token).unwrap().is_none() {
-                continue;
-            }
-
-            match inner.acquire(&key) {
-                Acquire::NotAvailable => break,
-                Acquire::Acquired(io, created) => {
-                    let tx = inner.waiters.get_mut(token).unwrap().take().unwrap().1;
-                    if let Err(conn) = tx.send(Ok(IoConnection::new(
-                        io,
-                        created,
-                        Some(Acquired(key.clone(), Some(self.inner.clone()))),
-                    ))) {
-                        let (io, created) = conn.unwrap().into_inner();
-                        inner.release_conn(&key, io, created);
-                    }
-                }
-                Acquire::Available => {
-                    let (connect, tx) =
-                        inner.waiters.get_mut(token).unwrap().take().unwrap();
-                    OpenWaitingConnection::spawn(
-                        key.clone(),
-                        tx,
-                        self.inner.clone(),
-                        self.connector.call(connect),
-                    );
-                }
-            }
-            let _ = inner.waiters_queue.swap_remove_index(0);
-        }
-
-        Ok(Async::NotReady)
-    }
-}
-
-struct OpenWaitingConnection<F, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fut: F,
-    key: Key,
-    h2: Option<Handshake<Io, Bytes>>,
-    rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
-    inner: Option<Rc<RefCell<Inner<Io>>>>,
-}
-
-impl<F, Io> OpenWaitingConnection<F, Io>
-where
-    F: Future<Item = (Io, Protocol), Error = ConnectError> + 'static,
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fn spawn(
-        key: Key,
-        rx: oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
-        inner: Rc<RefCell<Inner<Io>>>,
-        fut: F,
-    ) {
-        tokio_current_thread::spawn(OpenWaitingConnection {
-            key,
-            fut,
-            h2: None,
-            rx: Some(rx),
-            inner: Some(inner),
-        })
-    }
-}
-
-impl<F, Io> Drop for OpenWaitingConnection<F, Io>
-where
-    Io: AsyncRead + AsyncWrite + 'static,
-{
-    fn drop(&mut self) {
-        if let Some(inner) = self.inner.take() {
-            let mut inner = inner.as_ref().borrow_mut();
-            inner.release();
-            inner.check_availibility();
-        }
-    }
-}
-
-impl<F, Io> Future for OpenWaitingConnection<F, Io>
-where
-    F: Future<Item = (Io, Protocol), Error = ConnectError>,
-    Io: AsyncRead + AsyncWrite,
-{
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut h2) = self.h2 {
-            return match h2.poll() {
-                Ok(Async::Ready((snd, connection))) => {
-                    tokio_current_thread::spawn(connection.map_err(|_| ()));
-                    let rx = self.rx.take().unwrap();
-                    let _ = rx.send(Ok(IoConnection::new(
-                        ConnectionType::H2(snd),
-                        Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.take())),
-                    )));
-                    Ok(Async::Ready(()))
-                }
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-                Err(err) => {
-                    let _ = self.inner.take();
-                    if let Some(rx) = self.rx.take() {
-                        let _ = rx.send(Err(ConnectError::H2(err)));
-                    }
-                    Err(())
-                }
-            };
-        }
-
-        match self.fut.poll() {
-            Err(err) => {
-                let _ = self.inner.take();
-                if let Some(rx) = self.rx.take() {
-                    let _ = rx.send(Err(err));
-                }
-                Err(())
-            }
-            Ok(Async::Ready((io, proto))) => {
-                if proto == Protocol::Http1 {
-                    let rx = self.rx.take().unwrap();
-                    let _ = rx.send(Ok(IoConnection::new(
-                        ConnectionType::H1(io),
-                        Instant::now(),
-                        Some(Acquired(self.key.clone(), self.inner.take())),
-                    )));
-                    Ok(Async::Ready(()))
-                } else {
-                    self.h2 = Some(handshake(io));
-                    self.poll()
-                }
-            }
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-        }
-    }
-}
-
-pub(crate) struct Acquired<T>(Key, Option<Rc<RefCell<Inner<T>>>>);
-
-impl<T> Acquired<T>
-where
-    T: AsyncRead + AsyncWrite + 'static,
-{
-    pub(crate) fn close(&mut self, conn: IoConnection<T>) {
-        if let Some(inner) = self.1.take() {
-            let (io, _) = conn.into_inner();
-            inner.as_ref().borrow_mut().release_close(io);
-        }
-    }
-    pub(crate) fn release(&mut self, conn: IoConnection<T>) {
-        if let Some(inner) = self.1.take() {
-            let (io, created) = conn.into_inner();
-            inner
-                .as_ref()
-                .borrow_mut()
-                .release_conn(&self.0, io, created);
-        }
-    }
-}
-
-impl<T> Drop for Acquired<T> {
-    fn drop(&mut self) {
-        if let Some(inner) = self.1.take() {
-            inner.as_ref().borrow_mut().release();
-        }
-    }
-}
--- a/actix-http/src/cloneable.rs
+++ b/actix-http/src/cloneable.rs
@@ -1,42 +0,0 @@
-use std::cell::UnsafeCell;
-use std::rc::Rc;
-
-use actix_service::Service;
-use futures::Poll;
-
-#[doc(hidden)]
-/// Service that allows to turn non-clone service to a service with `Clone` impl
-pub(crate) struct CloneableService<T>(Rc<UnsafeCell<T>>);
-
-impl<T> CloneableService<T> {
-    pub(crate) fn new(service: T) -> Self
-    where
-        T: Service,
-    {
-        Self(Rc::new(UnsafeCell::new(service)))
-    }
-}
-
-impl<T> Clone for CloneableService<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<T> Service for CloneableService<T>
-where
-    T: Service,
-{
-    type Request = T::Request;
-    type Response = T::Response;
-    type Error = T::Error;
-    type Future = T::Future;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        unsafe { &mut *self.0.as_ref().get() }.poll_ready()
-    }
-
-    fn call(&mut self, req: T::Request) -> Self::Future {
-        unsafe { &mut *self.0.as_ref().get() }.call(req)
-    }
-}
--- a/actix-http/src/config.rs
+++ b/actix-http/src/config.rs
@@ -1,290 +0,0 @@
-use std::cell::UnsafeCell;
-use std::fmt;
-use std::fmt::Write;
-use std::rc::Rc;
-use std::time::{Duration, Instant};
-
-use bytes::BytesMut;
-use futures::{future, Future};
-use time;
-use tokio_timer::{sleep, Delay};
-
-// "Sun, 06 Nov 1994 08:49:37 GMT".len()
-const DATE_VALUE_LENGTH: usize = 29;
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-/// Server keep-alive setting
-pub enum KeepAlive {
-    /// Keep alive in seconds
-    Timeout(usize),
-    /// Relay on OS to shutdown tcp connection
-    Os,
-    /// Disabled
-    Disabled,
-}
-
-impl From<usize> for KeepAlive {
-    fn from(keepalive: usize) -> Self {
-        KeepAlive::Timeout(keepalive)
-    }
-}
-
-impl From<Option<usize>> for KeepAlive {
-    fn from(keepalive: Option<usize>) -> Self {
-        if let Some(keepalive) = keepalive {
-            KeepAlive::Timeout(keepalive)
-        } else {
-            KeepAlive::Disabled
-        }
-    }
-}
-
-/// Http service configuration
-pub struct ServiceConfig(Rc<Inner>);
-
-struct Inner {
-    keep_alive: Option<Duration>,
-    client_timeout: u64,
-    client_disconnect: u64,
-    ka_enabled: bool,
-    timer: DateService,
-}
-
-impl Clone for ServiceConfig {
-    fn clone(&self) -> Self {
-        ServiceConfig(self.0.clone())
-    }
-}
-
-impl Default for ServiceConfig {
-    fn default() -> Self {
-        Self::new(KeepAlive::Timeout(5), 0, 0)
-    }
-}
-
-impl ServiceConfig {
-    /// Create instance of `ServiceConfig`
-    pub fn new(
-        keep_alive: KeepAlive,
-        client_timeout: u64,
-        client_disconnect: u64,
-    ) -> ServiceConfig {
-        let (keep_alive, ka_enabled) = match keep_alive {
-            KeepAlive::Timeout(val) => (val as u64, true),
-            KeepAlive::Os => (0, true),
-            KeepAlive::Disabled => (0, false),
-        };
-        let keep_alive = if ka_enabled && keep_alive > 0 {
-            Some(Duration::from_secs(keep_alive))
-        } else {
-            None
-        };
-
-        ServiceConfig(Rc::new(Inner {
-            keep_alive,
-            ka_enabled,
-            client_timeout,
-            client_disconnect,
-            timer: DateService::new(),
-        }))
-    }
-
-    #[inline]
-    /// Keep alive duration if configured.
-    pub fn keep_alive(&self) -> Option<Duration> {
-        self.0.keep_alive
-    }
-
-    #[inline]
-    /// Return state of connection keep-alive funcitonality
-    pub fn keep_alive_enabled(&self) -> bool {
-        self.0.ka_enabled
-    }
-
-    #[inline]
-    /// Client timeout for first request.
-    pub fn client_timer(&self) -> Option<Delay> {
-        let delay = self.0.client_timeout;
-        if delay != 0 {
-            Some(Delay::new(
-                self.0.timer.now() + Duration::from_millis(delay),
-            ))
-        } else {
-            None
-        }
-    }
-
-    /// Client timeout for first request.
-    pub fn client_timer_expire(&self) -> Option<Instant> {
-        let delay = self.0.client_timeout;
-        if delay != 0 {
-            Some(self.0.timer.now() + Duration::from_millis(delay))
-        } else {
-            None
-        }
-    }
-
-    /// Client disconnect timer
-    pub fn client_disconnect_timer(&self) -> Option<Instant> {
-        let delay = self.0.client_disconnect;
-        if delay != 0 {
-            Some(self.0.timer.now() + Duration::from_millis(delay))
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    /// Return keep-alive timer delay is configured.
-    pub fn keep_alive_timer(&self) -> Option<Delay> {
-        if let Some(ka) = self.0.keep_alive {
-            Some(Delay::new(self.0.timer.now() + ka))
-        } else {
-            None
-        }
-    }
-
-    /// Keep-alive expire time
-    pub fn keep_alive_expire(&self) -> Option<Instant> {
-        if let Some(ka) = self.0.keep_alive {
-            Some(self.0.timer.now() + ka)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn now(&self) -> Instant {
-        self.0.timer.now()
-    }
-
-    #[doc(hidden)]
-    pub fn set_date(&self, dst: &mut BytesMut) {
-        let mut buf: [u8; 39] = [0; 39];
-        buf[..6].copy_from_slice(b"date: ");
-        self.0
-            .timer
-            .set_date(|date| buf[6..35].copy_from_slice(&date.bytes));
-        buf[35..].copy_from_slice(b"\r\n\r\n");
-        dst.extend_from_slice(&buf);
-    }
-
-    pub(crate) fn set_date_header(&self, dst: &mut BytesMut) {
-        self.0
-            .timer
-            .set_date(|date| dst.extend_from_slice(&date.bytes));
-    }
-}
-
-#[derive(Copy, Clone)]
-struct Date {
-    bytes: [u8; DATE_VALUE_LENGTH],
-    pos: usize,
-}
-
-impl Date {
-    fn new() -> Date {
-        let mut date = Date {
-            bytes: [0; DATE_VALUE_LENGTH],
-            pos: 0,
-        };
-        date.update();
-        date
-    }
-    fn update(&mut self) {
-        self.pos = 0;
-        write!(self, "{}", time::at_utc(time::get_time()).rfc822()).unwrap();
-    }
-}
-
-impl fmt::Write for Date {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        let len = s.len();
-        self.bytes[self.pos..self.pos + len].copy_from_slice(s.as_bytes());
-        self.pos += len;
-        Ok(())
-    }
-}
-
-#[derive(Clone)]
-struct DateService(Rc<DateServiceInner>);
-
-struct DateServiceInner {
-    current: UnsafeCell<Option<(Date, Instant)>>,
-}
-
-impl DateServiceInner {
-    fn new() -> Self {
-        DateServiceInner {
-            current: UnsafeCell::new(None),
-        }
-    }
-
-    fn reset(&self) {
-        unsafe { (&mut *self.current.get()).take() };
-    }
-
-    fn update(&self) {
-        let now = Instant::now();
-        let date = Date::new();
-        *(unsafe { &mut *self.current.get() }) = Some((date, now));
-    }
-}
-
-impl DateService {
-    fn new() -> Self {
-        DateService(Rc::new(DateServiceInner::new()))
-    }
-
-    fn check_date(&self) {
-        if unsafe { (&*self.0.current.get()).is_none() } {
-            self.0.update();
-
-            // periodic date update
-            let s = self.clone();
-            tokio_current_thread::spawn(sleep(Duration::from_millis(500)).then(
-                move |_| {
-                    s.0.reset();
-                    future::ok(())
-                },
-            ));
-        }
-    }
-
-    fn now(&self) -> Instant {
-        self.check_date();
-        unsafe { (&*self.0.current.get()).as_ref().unwrap().1 }
-    }
-
-    fn set_date<F: FnMut(&Date)>(&self, mut f: F) {
-        self.check_date();
-        f(&unsafe { (&*self.0.current.get()).as_ref().unwrap().0 })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use actix_rt::System;
-    use futures::future;
-
-    #[test]
-    fn test_date_len() {
-        assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
-    }
-
-    #[test]
-    fn test_date() {
-        let mut rt = System::new("test");
-
-        let _ = rt.block_on(future::lazy(|| {
-            let settings = ServiceConfig::new(KeepAlive::Os, 0, 0);
-            let mut buf1 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
-            settings.set_date(&mut buf1);
-            let mut buf2 = BytesMut::with_capacity(DATE_VALUE_LENGTH + 10);
-            settings.set_date(&mut buf2);
-            assert_eq!(buf1, buf2);
-            future::ok::<_, ()>(())
-        }));
-    }
-}
--- a/actix-http/src/cookie/builder.rs
+++ b/actix-http/src/cookie/builder.rs
@@ -1,260 +0,0 @@
-use std::borrow::Cow;
-
-use chrono::Duration;
-use time::Tm;
-
-use super::{Cookie, SameSite};
-
-/// Structure that follows the builder pattern for building `Cookie` structs.
-///
-/// To construct a cookie:
-///
-///   1. Call [`Cookie::build`](struct.Cookie.html#method.build) to start building.
-///   2. Use any of the builder methods to set fields in the cookie.
-///   3. Call [finish](#method.finish) to retrieve the built cookie.
-///
-/// # Example
-///
-/// ```rust
-/// use actix_http::cookie::Cookie;
-///
-/// # fn main() {
-/// let cookie: Cookie = Cookie::build("name", "value")
-///     .domain("www.rust-lang.org")
-///     .path("/")
-///     .secure(true)
-///     .http_only(true)
-///     .max_age(84600)
-///     .finish();
-/// # }
-/// ```
-#[derive(Debug, Clone)]
-pub struct CookieBuilder {
-    /// The cookie being built.
-    cookie: Cookie<'static>,
-}
-
-impl CookieBuilder {
-    /// Creates a new `CookieBuilder` instance from the given name and value.
-    ///
-    /// This method is typically called indirectly via
-    /// [Cookie::build](struct.Cookie.html#method.build).
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar").finish();
-    /// assert_eq!(c.name_value(), ("foo", "bar"));
-    /// ```
-    pub fn new<N, V>(name: N, value: V) -> CookieBuilder
-    where
-        N: Into<Cow<'static, str>>,
-        V: Into<Cow<'static, str>>,
-    {
-        CookieBuilder {
-            cookie: Cookie::new(name, value),
-        }
-    }
-
-    /// Sets the `expires` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// # fn main() {
-    /// let c = Cookie::build("foo", "bar")
-    ///     .expires(time::now())
-    ///     .finish();
-    ///
-    /// assert!(c.expires().is_some());
-    /// # }
-    /// ```
-    #[inline]
-    pub fn expires(mut self, when: Tm) -> CookieBuilder {
-        self.cookie.set_expires(when);
-        self
-    }
-
-    /// Sets the `max_age` field in seconds in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// # fn main() {
-    /// let c = Cookie::build("foo", "bar")
-    ///     .max_age(1800)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
-    /// # }
-    /// ```
-    #[inline]
-    pub fn max_age(self, seconds: i64) -> CookieBuilder {
-        self.max_age_time(Duration::seconds(seconds))
-    }
-
-    /// Sets the `max_age` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// # fn main() {
-    /// let c = Cookie::build("foo", "bar")
-    ///     .max_age_time(time::Duration::minutes(30))
-    ///     .finish();
-    ///
-    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
-    /// # }
-    /// ```
-    #[inline]
-    pub fn max_age_time(mut self, value: Duration) -> CookieBuilder {
-        self.cookie.set_max_age(value);
-        self
-    }
-
-    /// Sets the `domain` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .domain("www.rust-lang.org")
-    ///     .finish();
-    ///
-    /// assert_eq!(c.domain(), Some("www.rust-lang.org"));
-    /// ```
-    pub fn domain<D: Into<Cow<'static, str>>>(mut self, value: D) -> CookieBuilder {
-        self.cookie.set_domain(value);
-        self
-    }
-
-    /// Sets the `path` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .path("/")
-    ///     .finish();
-    ///
-    /// assert_eq!(c.path(), Some("/"));
-    /// ```
-    pub fn path<P: Into<Cow<'static, str>>>(mut self, path: P) -> CookieBuilder {
-        self.cookie.set_path(path);
-        self
-    }
-
-    /// Sets the `secure` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .secure(true)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.secure(), Some(true));
-    /// ```
-    #[inline]
-    pub fn secure(mut self, value: bool) -> CookieBuilder {
-        self.cookie.set_secure(value);
-        self
-    }
-
-    /// Sets the `http_only` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .http_only(true)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.http_only(), Some(true));
-    /// ```
-    #[inline]
-    pub fn http_only(mut self, value: bool) -> CookieBuilder {
-        self.cookie.set_http_only(value);
-        self
-    }
-
-    /// Sets the `same_site` field in the cookie being built.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{Cookie, SameSite};
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .same_site(SameSite::Strict)
-    ///     .finish();
-    ///
-    /// assert_eq!(c.same_site(), Some(SameSite::Strict));
-    /// ```
-    #[inline]
-    pub fn same_site(mut self, value: SameSite) -> CookieBuilder {
-        self.cookie.set_same_site(value);
-        self
-    }
-
-    /// Makes the cookie being built 'permanent' by extending its expiration and
-    /// max age 20 years into the future.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    /// use chrono::Duration;
-    ///
-    /// # fn main() {
-    /// let c = Cookie::build("foo", "bar")
-    ///     .permanent()
-    ///     .finish();
-    ///
-    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
-    /// # assert!(c.expires().is_some());
-    /// # }
-    /// ```
-    #[inline]
-    pub fn permanent(mut self) -> CookieBuilder {
-        self.cookie.make_permanent();
-        self
-    }
-
-    /// Finishes building and returns the built `Cookie`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Cookie;
-    ///
-    /// let c = Cookie::build("foo", "bar")
-    ///     .domain("crates.io")
-    ///     .path("/")
-    ///     .finish();
-    ///
-    /// assert_eq!(c.name_value(), ("foo", "bar"));
-    /// assert_eq!(c.domain(), Some("crates.io"));
-    /// assert_eq!(c.path(), Some("/"));
-    /// ```
-    #[inline]
-    pub fn finish(self) -> Cookie<'static> {
-        self.cookie
-    }
-}
--- a/actix-http/src/cookie/delta.rs
+++ b/actix-http/src/cookie/delta.rs
@@ -1,71 +0,0 @@
-use std::borrow::Borrow;
-use std::hash::{Hash, Hasher};
-use std::ops::{Deref, DerefMut};
-
-use super::Cookie;
-
-/// A `DeltaCookie` is a helper structure used in a cookie jar. It wraps a
-/// `Cookie` so that it can be hashed and compared purely by name. It further
-/// records whether the wrapped cookie is a "removal" cookie, that is, a cookie
-/// that when sent to the client removes the named cookie on the client's
-/// machine.
-#[derive(Clone, Debug)]
-pub struct DeltaCookie {
-    pub cookie: Cookie<'static>,
-    pub removed: bool,
-}
-
-impl DeltaCookie {
-    /// Create a new `DeltaCookie` that is being added to a jar.
-    #[inline]
-    pub fn added(cookie: Cookie<'static>) -> DeltaCookie {
-        DeltaCookie {
-            cookie,
-            removed: false,
-        }
-    }
-
-    /// Create a new `DeltaCookie` that is being removed from a jar. The
-    /// `cookie` should be a "removal" cookie.
-    #[inline]
-    pub fn removed(cookie: Cookie<'static>) -> DeltaCookie {
-        DeltaCookie {
-            cookie,
-            removed: true,
-        }
-    }
-}
-
-impl Deref for DeltaCookie {
-    type Target = Cookie<'static>;
-
-    fn deref(&self) -> &Cookie<'static> {
-        &self.cookie
-    }
-}
-
-impl DerefMut for DeltaCookie {
-    fn deref_mut(&mut self) -> &mut Cookie<'static> {
-        &mut self.cookie
-    }
-}
-
-impl PartialEq for DeltaCookie {
-    fn eq(&self, other: &DeltaCookie) -> bool {
-        self.name() == other.name()
-    }
-}
-
-impl Eq for DeltaCookie {}
-
-impl Hash for DeltaCookie {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.name().hash(state);
-    }
-}
-
-impl Borrow<str> for DeltaCookie {
-    fn borrow(&self) -> &str {
-        self.name()
-    }
-}
--- a/actix-http/src/cookie/draft.rs
+++ b/actix-http/src/cookie/draft.rs
@@ -1,98 +0,0 @@
-//! This module contains types that represent cookie properties that are not yet
-//! standardized. That is, _draft_ features.
-
-use std::fmt;
-
-/// The `SameSite` cookie attribute.
-///
-/// A cookie with a `SameSite` attribute is imposed restrictions on when it is
-/// sent to the origin server in a cross-site request. If the `SameSite`
-/// attribute is "Strict", then the cookie is never sent in cross-site requests.
-/// If the `SameSite` attribute is "Lax", the cookie is only sent in cross-site
-/// requests with "safe" HTTP methods, i.e, `GET`, `HEAD`, `OPTIONS`, `TRACE`.
-/// If the `SameSite` attribute is not present (made explicit via the
-/// `SameSite::None` variant), then the cookie will be sent as normal.
-///
-/// **Note:** This cookie attribute is an HTTP draft! Its meaning and definition
-/// are subject to change.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum SameSite {
-    /// The "Strict" `SameSite` attribute.
-    Strict,
-    /// The "Lax" `SameSite` attribute.
-    Lax,
-    /// No `SameSite` attribute.
-    None,
-}
-
-impl SameSite {
-    /// Returns `true` if `self` is `SameSite::Strict` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::SameSite;
-    ///
-    /// let strict = SameSite::Strict;
-    /// assert!(strict.is_strict());
-    /// assert!(!strict.is_lax());
-    /// assert!(!strict.is_none());
-    /// ```
-    #[inline]
-    pub fn is_strict(self) -> bool {
-        match self {
-            SameSite::Strict => true,
-            SameSite::Lax | SameSite::None => false,
-        }
-    }
-
-    /// Returns `true` if `self` is `SameSite::Lax` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::SameSite;
-    ///
-    /// let lax = SameSite::Lax;
-    /// assert!(lax.is_lax());
-    /// assert!(!lax.is_strict());
-    /// assert!(!lax.is_none());
-    /// ```
-    #[inline]
-    pub fn is_lax(self) -> bool {
-        match self {
-            SameSite::Lax => true,
-            SameSite::Strict | SameSite::None => false,
-        }
-    }
-
-    /// Returns `true` if `self` is `SameSite::None` and `false` otherwise.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::SameSite;
-    ///
-    /// let none = SameSite::None;
-    /// assert!(none.is_none());
-    /// assert!(!none.is_lax());
-    /// assert!(!none.is_strict());
-    /// ```
-    #[inline]
-    pub fn is_none(self) -> bool {
-        match self {
-            SameSite::None => true,
-            SameSite::Lax | SameSite::Strict => false,
-        }
-    }
-}
-
-impl fmt::Display for SameSite {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            SameSite::Strict => write!(f, "Strict"),
-            SameSite::Lax => write!(f, "Lax"),
-            SameSite::None => Ok(()),
-        }
-    }
-}
--- a/actix-http/src/cookie/jar.rs
+++ b/actix-http/src/cookie/jar.rs
@@ -1,655 +0,0 @@
-use std::collections::HashSet;
-use std::mem::replace;
-
-use chrono::Duration;
-
-use super::delta::DeltaCookie;
-use super::Cookie;
-
-#[cfg(feature = "secure-cookies")]
-use super::secure::{Key, PrivateJar, SignedJar};
-
-/// A collection of cookies that tracks its modifications.
-///
-/// A `CookieJar` provides storage for any number of cookies. Any changes made
-/// to the jar are tracked; the changes can be retrieved via the
-/// [delta](#method.delta) method which returns an interator over the changes.
-///
-/// # Usage
-///
-/// A jar's life begins via [new](#method.new) and calls to
-/// [`add_original`](#method.add_original):
-///
-/// ```rust
-/// use actix_http::cookie::{Cookie, CookieJar};
-///
-/// let mut jar = CookieJar::new();
-/// jar.add_original(Cookie::new("name", "value"));
-/// jar.add_original(Cookie::new("second", "another"));
-/// ```
-///
-/// Cookies can be added via [add](#method.add) and removed via
-/// [remove](#method.remove). Finally, cookies can be looked up via
-/// [get](#method.get):
-///
-/// ```rust
-/// # use actix_http::cookie::{Cookie, CookieJar};
-/// let mut jar = CookieJar::new();
-/// jar.add(Cookie::new("a", "one"));
-/// jar.add(Cookie::new("b", "two"));
-///
-/// assert_eq!(jar.get("a").map(|c| c.value()), Some("one"));
-/// assert_eq!(jar.get("b").map(|c| c.value()), Some("two"));
-///
-/// jar.remove(Cookie::named("b"));
-/// assert!(jar.get("b").is_none());
-/// ```
-///
-/// # Deltas
-///
-/// A jar keeps track of any modifications made to it over time. The
-/// modifications are recorded as cookies. The modifications can be retrieved
-/// via [delta](#method.delta). Any new `Cookie` added to a jar via `add`
-/// results in the same `Cookie` appearing in the `delta`; cookies added via
-/// `add_original` do not count towards the delta. Any _original_ cookie that is
-/// removed from a jar results in a "removal" cookie appearing in the delta. A
-/// "removal" cookie is a cookie that a server sends so that the cookie is
-/// removed from the client's machine.
-///
-/// Deltas are typically used to create `Set-Cookie` headers corresponding to
-/// the changes made to a cookie jar over a period of time.
-///
-/// ```rust
-/// # use actix_http::cookie::{Cookie, CookieJar};
-/// let mut jar = CookieJar::new();
-///
-/// // original cookies don't affect the delta
-/// jar.add_original(Cookie::new("original", "value"));
-/// assert_eq!(jar.delta().count(), 0);
-///
-/// // new cookies result in an equivalent `Cookie` in the delta
-/// jar.add(Cookie::new("a", "one"));
-/// jar.add(Cookie::new("b", "two"));
-/// assert_eq!(jar.delta().count(), 2);
-///
-/// // removing an original cookie adds a "removal" cookie to the delta
-/// jar.remove(Cookie::named("original"));
-/// assert_eq!(jar.delta().count(), 3);
-///
-/// // removing a new cookie that was added removes that `Cookie` from the delta
-/// jar.remove(Cookie::named("a"));
-/// assert_eq!(jar.delta().count(), 2);
-/// ```
-#[derive(Default, Debug, Clone)]
-pub struct CookieJar {
-    original_cookies: HashSet<DeltaCookie>,
-    delta_cookies: HashSet<DeltaCookie>,
-}
-
-impl CookieJar {
-    /// Creates an empty cookie jar.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::CookieJar;
-    ///
-    /// let jar = CookieJar::new();
-    /// assert_eq!(jar.iter().count(), 0);
-    /// ```
-    pub fn new() -> CookieJar {
-        CookieJar::default()
-    }
-
-    /// Returns a reference to the `Cookie` inside this jar with the name
-    /// `name`. If no such cookie exists, returns `None`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// assert!(jar.get("name").is_none());
-    ///
-    /// jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
-    /// ```
-    pub fn get(&self, name: &str) -> Option<&Cookie<'static>> {
-        self.delta_cookies
-            .get(name)
-            .or_else(|| self.original_cookies.get(name))
-            .and_then(|c| if !c.removed { Some(&c.cookie) } else { None })
-    }
-
-    /// Adds an "original" `cookie` to this jar. If an original cookie with the
-    /// same name already exists, it is replaced with `cookie`. Cookies added
-    /// with `add` take precedence and are not replaced by this method.
-    ///
-    /// Adding an original cookie does not affect the [delta](#method.delta)
-    /// computation. This method is intended to be used to seed the cookie jar
-    /// with cookies received from a client's HTTP message.
-    ///
-    /// For accurate `delta` computations, this method should not be called
-    /// after calling `remove`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add_original(Cookie::new("second", "two"));
-    ///
-    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
-    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
-    /// assert_eq!(jar.iter().count(), 2);
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn add_original(&mut self, cookie: Cookie<'static>) {
-        self.original_cookies.replace(DeltaCookie::added(cookie));
-    }
-
-    /// Adds `cookie` to this jar. If a cookie with the same name already
-    /// exists, it is replaced with `cookie`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add(Cookie::new("name", "value"));
-    /// jar.add(Cookie::new("second", "two"));
-    ///
-    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
-    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
-    /// assert_eq!(jar.iter().count(), 2);
-    /// assert_eq!(jar.delta().count(), 2);
-    /// ```
-    pub fn add(&mut self, cookie: Cookie<'static>) {
-        self.delta_cookies.replace(DeltaCookie::added(cookie));
-    }
-
-    /// Removes `cookie` from this jar. If an _original_ cookie with the same
-    /// name as `cookie` is present in the jar, a _removal_ cookie will be
-    /// present in the `delta` computation. To properly generate the removal
-    /// cookie, `cookie` must contain the same `path` and `domain` as the cookie
-    /// that was initially set.
-    ///
-    /// A "removal" cookie is a cookie that has the same name as the original
-    /// cookie but has an empty value, a max-age of 0, and an expiration date
-    /// far in the past.
-    ///
-    /// # Example
-    ///
-    /// Removing an _original_ cookie results in a _removal_ cookie:
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use chrono::Duration;
-    ///
-    /// # fn main() {
-    /// let mut jar = CookieJar::new();
-    ///
-    /// // Assume this cookie originally had a path of "/" and domain of "a.b".
-    /// jar.add_original(Cookie::new("name", "value"));
-    ///
-    /// // If the path and domain were set, they must be provided to `remove`.
-    /// jar.remove(Cookie::build("name", "").path("/").domain("a.b").finish());
-    ///
-    /// // The delta will contain the removal cookie.
-    /// let delta: Vec<_> = jar.delta().collect();
-    /// assert_eq!(delta.len(), 1);
-    /// assert_eq!(delta[0].name(), "name");
-    /// assert_eq!(delta[0].max_age(), Some(Duration::seconds(0)));
-    /// # }
-    /// ```
-    ///
-    /// Removing a new cookie does not result in a _removal_ cookie:
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(jar.delta().count(), 1);
-    ///
-    /// jar.remove(Cookie::named("name"));
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn remove(&mut self, mut cookie: Cookie<'static>) {
-        if self.original_cookies.contains(cookie.name()) {
-            cookie.set_value("");
-            cookie.set_max_age(Duration::seconds(0));
-            cookie.set_expires(time::now() - Duration::days(365));
-            self.delta_cookies.replace(DeltaCookie::removed(cookie));
-        } else {
-            self.delta_cookies.remove(cookie.name());
-        }
-    }
-
-    /// Removes `cookie` from this jar completely. This method differs from
-    /// `remove` in that no delta cookie is created under any condition. Neither
-    /// the `delta` nor `iter` methods will return a cookie that is removed
-    /// using this method.
-    ///
-    /// # Example
-    ///
-    /// Removing an _original_ cookie; no _removal_ cookie is generated:
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use chrono::Duration;
-    ///
-    /// # fn main() {
-    /// let mut jar = CookieJar::new();
-    ///
-    /// // Add an original cookie and a new cookie.
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add(Cookie::new("key", "value"));
-    /// assert_eq!(jar.delta().count(), 1);
-    /// assert_eq!(jar.iter().count(), 2);
-    ///
-    /// // Now force remove the original cookie.
-    /// jar.force_remove(Cookie::new("name", "value"));
-    /// assert_eq!(jar.delta().count(), 1);
-    /// assert_eq!(jar.iter().count(), 1);
-    ///
-    /// // Now force remove the new cookie.
-    /// jar.force_remove(Cookie::new("key", "value"));
-    /// assert_eq!(jar.delta().count(), 0);
-    /// assert_eq!(jar.iter().count(), 0);
-    /// # }
-    /// ```
-    pub fn force_remove<'a>(&mut self, cookie: Cookie<'a>) {
-        self.original_cookies.remove(cookie.name());
-        self.delta_cookies.remove(cookie.name());
-    }
-
-    /// Removes all cookies from this cookie jar.
-    #[deprecated(
-        since = "0.7.0",
-        note = "calling this method may not remove \
-                all cookies since the path and domain are not specified; use \
-                `remove` instead"
-    )]
-    pub fn clear(&mut self) {
-        self.delta_cookies.clear();
-        for delta in replace(&mut self.original_cookies, HashSet::new()) {
-            self.remove(delta.cookie);
-        }
-    }
-
-    /// Returns an iterator over cookies that represent the changes to this jar
-    /// over time. These cookies can be rendered directly as `Set-Cookie` header
-    /// values to affect the changes made to this jar on the client.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add_original(Cookie::new("second", "two"));
-    ///
-    /// // Add new cookies.
-    /// jar.add(Cookie::new("new", "third"));
-    /// jar.add(Cookie::new("another", "fourth"));
-    /// jar.add(Cookie::new("yac", "fifth"));
-    ///
-    /// // Remove some cookies.
-    /// jar.remove(Cookie::named("name"));
-    /// jar.remove(Cookie::named("another"));
-    ///
-    /// // Delta contains two new cookies ("new", "yac") and a removal ("name").
-    /// assert_eq!(jar.delta().count(), 3);
-    /// ```
-    pub fn delta(&self) -> Delta {
-        Delta {
-            iter: self.delta_cookies.iter(),
-        }
-    }
-
-    /// Returns an iterator over all of the cookies present in this jar.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie};
-    ///
-    /// let mut jar = CookieJar::new();
-    ///
-    /// jar.add_original(Cookie::new("name", "value"));
-    /// jar.add_original(Cookie::new("second", "two"));
-    ///
-    /// jar.add(Cookie::new("new", "third"));
-    /// jar.add(Cookie::new("another", "fourth"));
-    /// jar.add(Cookie::new("yac", "fifth"));
-    ///
-    /// jar.remove(Cookie::named("name"));
-    /// jar.remove(Cookie::named("another"));
-    ///
-    /// // There are three cookies in the jar: "second", "new", and "yac".
-    /// # assert_eq!(jar.iter().count(), 3);
-    /// for cookie in jar.iter() {
-    ///     match cookie.name() {
-    ///         "second" => assert_eq!(cookie.value(), "two"),
-    ///         "new" => assert_eq!(cookie.value(), "third"),
-    ///         "yac" => assert_eq!(cookie.value(), "fifth"),
-    ///         _ => unreachable!("there are only three cookies in the jar")
-    ///     }
-    /// }
-    /// ```
-    pub fn iter(&self) -> Iter {
-        Iter {
-            delta_cookies: self
-                .delta_cookies
-                .iter()
-                .chain(self.original_cookies.difference(&self.delta_cookies)),
-        }
-    }
-
-    /// Returns a `PrivateJar` with `self` as its parent jar using the key `key`
-    /// to sign/encrypt and verify/decrypt cookies added/retrieved from the
-    /// child jar.
-    ///
-    /// Any modifications to the child jar will be reflected on the parent jar,
-    /// and any retrievals from the child jar will be made from the parent jar.
-    ///
-    /// This method is only available when the `secure` feature is enabled.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{Cookie, CookieJar, Key};
-    ///
-    /// // Generate a secure key.
-    /// let key = Key::generate();
-    ///
-    /// // Add a private (signed + encrypted) cookie.
-    /// let mut jar = CookieJar::new();
-    /// jar.private(&key).add(Cookie::new("private", "text"));
-    ///
-    /// // The cookie's contents are encrypted.
-    /// assert_ne!(jar.get("private").unwrap().value(), "text");
-    ///
-    /// // They can be decrypted and verified through the child jar.
-    /// assert_eq!(jar.private(&key).get("private").unwrap().value(), "text");
-    ///
-    /// // A tampered with cookie does not validate but still exists.
-    /// let mut cookie = jar.get("private").unwrap().clone();
-    /// jar.add(Cookie::new("private", cookie.value().to_string() + "!"));
-    /// assert!(jar.private(&key).get("private").is_none());
-    /// assert!(jar.get("private").is_some());
-    /// ```
-    #[cfg(feature = "secure-cookies")]
-    pub fn private(&mut self, key: &Key) -> PrivateJar {
-        PrivateJar::new(self, key)
-    }
-
-    /// Returns a `SignedJar` with `self` as its parent jar using the key `key`
-    /// to sign/verify cookies added/retrieved from the child jar.
-    ///
-    /// Any modifications to the child jar will be reflected on the parent jar,
-    /// and any retrievals from the child jar will be made from the parent jar.
-    ///
-    /// This method is only available when the `secure` feature is enabled.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{Cookie, CookieJar, Key};
-    ///
-    /// // Generate a secure key.
-    /// let key = Key::generate();
-    ///
-    /// // Add a signed cookie.
-    /// let mut jar = CookieJar::new();
-    /// jar.signed(&key).add(Cookie::new("signed", "text"));
-    ///
-    /// // The cookie's contents are signed but still in plaintext.
-    /// assert_ne!(jar.get("signed").unwrap().value(), "text");
-    /// assert!(jar.get("signed").unwrap().value().contains("text"));
-    ///
-    /// // They can be verified through the child jar.
-    /// assert_eq!(jar.signed(&key).get("signed").unwrap().value(), "text");
-    ///
-    /// // A tampered with cookie does not validate but still exists.
-    /// let mut cookie = jar.get("signed").unwrap().clone();
-    /// jar.add(Cookie::new("signed", cookie.value().to_string() + "!"));
-    /// assert!(jar.signed(&key).get("signed").is_none());
-    /// assert!(jar.get("signed").is_some());
-    /// ```
-    #[cfg(feature = "secure-cookies")]
-    pub fn signed(&mut self, key: &Key) -> SignedJar {
-        SignedJar::new(self, key)
-    }
-}
-
-use std::collections::hash_set::Iter as HashSetIter;
-
-/// Iterator over the changes to a cookie jar.
-pub struct Delta<'a> {
-    iter: HashSetIter<'a, DeltaCookie>,
-}
-
-impl<'a> Iterator for Delta<'a> {
-    type Item = &'a Cookie<'static>;
-
-    fn next(&mut self) -> Option<&'a Cookie<'static>> {
-        self.iter.next().map(|c| &c.cookie)
-    }
-}
-
-use std::collections::hash_map::RandomState;
-use std::collections::hash_set::Difference;
-use std::iter::Chain;
-
-/// Iterator over all of the cookies in a jar.
-pub struct Iter<'a> {
-    delta_cookies:
-        Chain<HashSetIter<'a, DeltaCookie>, Difference<'a, DeltaCookie, RandomState>>,
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = &'a Cookie<'static>;
-
-    fn next(&mut self) -> Option<&'a Cookie<'static>> {
-        for cookie in self.delta_cookies.by_ref() {
-            if !cookie.removed {
-                return Some(&*cookie);
-            }
-        }
-
-        None
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #[cfg(feature = "secure-cookies")]
-    use super::Key;
-    use super::{Cookie, CookieJar};
-
-    #[test]
-    #[allow(deprecated)]
-    fn simple() {
-        let mut c = CookieJar::new();
-
-        c.add(Cookie::new("test", ""));
-        c.add(Cookie::new("test2", ""));
-        c.remove(Cookie::named("test"));
-
-        assert!(c.get("test").is_none());
-        assert!(c.get("test2").is_some());
-
-        c.add(Cookie::new("test3", ""));
-        c.clear();
-
-        assert!(c.get("test").is_none());
-        assert!(c.get("test2").is_none());
-        assert!(c.get("test3").is_none());
-    }
-
-    #[test]
-    fn jar_is_send() {
-        fn is_send<T: Send>(_: T) -> bool {
-            true
-        }
-
-        assert!(is_send(CookieJar::new()))
-    }
-
-    #[test]
-    #[cfg(feature = "secure-cookies")]
-    fn iter() {
-        let key = Key::generate();
-        let mut c = CookieJar::new();
-
-        c.add_original(Cookie::new("original", "original"));
-
-        c.add(Cookie::new("test", "test"));
-        c.add(Cookie::new("test2", "test2"));
-        c.add(Cookie::new("test3", "test3"));
-        assert_eq!(c.iter().count(), 4);
-
-        c.signed(&key).add(Cookie::new("signed", "signed"));
-        c.private(&key).add(Cookie::new("encrypted", "encrypted"));
-        assert_eq!(c.iter().count(), 6);
-
-        c.remove(Cookie::named("test"));
-        assert_eq!(c.iter().count(), 5);
-
-        c.remove(Cookie::named("signed"));
-        c.remove(Cookie::named("test2"));
-        assert_eq!(c.iter().count(), 3);
-
-        c.add(Cookie::new("test2", "test2"));
-        assert_eq!(c.iter().count(), 4);
-
-        c.remove(Cookie::named("test2"));
-        assert_eq!(c.iter().count(), 3);
-    }
-
-    #[test]
-    #[cfg(feature = "secure-cookies")]
-    fn delta() {
-        use chrono::Duration;
-        use std::collections::HashMap;
-
-        let mut c = CookieJar::new();
-
-        c.add_original(Cookie::new("original", "original"));
-        c.add_original(Cookie::new("original1", "original1"));
-
-        c.add(Cookie::new("test", "test"));
-        c.add(Cookie::new("test2", "test2"));
-        c.add(Cookie::new("test3", "test3"));
-        c.add(Cookie::new("test4", "test4"));
-
-        c.remove(Cookie::named("test"));
-        c.remove(Cookie::named("original"));
-
-        assert_eq!(c.delta().count(), 4);
-
-        let names: HashMap<_, _> = c.delta().map(|c| (c.name(), c.max_age())).collect();
-
-        assert!(names.get("test2").unwrap().is_none());
-        assert!(names.get("test3").unwrap().is_none());
-        assert!(names.get("test4").unwrap().is_none());
-        assert_eq!(names.get("original").unwrap(), &Some(Duration::seconds(0)));
-    }
-
-    #[test]
-    fn replace_original() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::new("original_a", "a"));
-        jar.add_original(Cookie::new("original_b", "b"));
-        assert_eq!(jar.get("original_a").unwrap().value(), "a");
-
-        jar.add(Cookie::new("original_a", "av2"));
-        assert_eq!(jar.get("original_a").unwrap().value(), "av2");
-    }
-
-    #[test]
-    fn empty_delta() {
-        let mut jar = CookieJar::new();
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().count(), 1);
-    }
-
-    #[test]
-    fn add_remove_add() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        // The cookie's been deleted. Another original doesn't change that.
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().count(), 1);
-    }
-
-    #[test]
-    fn replace_remove() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 0);
-
-        jar.add(Cookie::new("name", "val"));
-        assert_eq!(jar.delta().count(), 1);
-        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
-
-        jar.remove(Cookie::named("name"));
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-    }
-
-    #[test]
-    fn remove_with_path() {
-        let mut jar = CookieJar::new();
-        jar.add_original(Cookie::build("name", "val").finish());
-        assert_eq!(jar.iter().count(), 1);
-        assert_eq!(jar.delta().count(), 0);
-        assert_eq!(jar.iter().filter(|c| c.path().is_none()).count(), 1);
-
-        jar.remove(Cookie::build("name", "").path("/").finish());
-        assert_eq!(jar.iter().count(), 0);
-        assert_eq!(jar.delta().count(), 1);
-        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
-        assert_eq!(jar.delta().filter(|c| c.path() == Some("/")).count(), 1);
-    }
-}
--- a/actix-http/src/cookie/mod.rs
+++ b/actix-http/src/cookie/mod.rs
--- a/actix-http/src/cookie/parse.rs
+++ b/actix-http/src/cookie/parse.rs
@@ -1,425 +0,0 @@
-use std::borrow::Cow;
-use std::cmp;
-use std::convert::From;
-use std::error::Error;
-use std::fmt;
-use std::str::Utf8Error;
-
-use chrono::Duration;
-use percent_encoding::percent_decode;
-
-use super::{Cookie, CookieStr, SameSite};
-
-/// Enum corresponding to a parsing error.
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum ParseError {
-    /// The cookie did not contain a name/value pair.
-    MissingPair,
-    /// The cookie's name was empty.
-    EmptyName,
-    /// Decoding the cookie's name or value resulted in invalid UTF-8.
-    Utf8Error(Utf8Error),
-    /// It is discouraged to exhaustively match on this enum as its variants may
-    /// grow without a breaking-change bump in version numbers.
-    #[doc(hidden)]
-    __Nonexhasutive,
-}
-
-impl ParseError {
-    /// Returns a description of this error as a string
-    pub fn as_str(&self) -> &'static str {
-        match *self {
-            ParseError::MissingPair => "the cookie is missing a name/value pair",
-            ParseError::EmptyName => "the cookie's name is empty",
-            ParseError::Utf8Error(_) => {
-                "decoding the cookie's name or value resulted in invalid UTF-8"
-            }
-            ParseError::__Nonexhasutive => unreachable!("__Nonexhasutive ParseError"),
-        }
-    }
-}
-
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-impl From<Utf8Error> for ParseError {
-    fn from(error: Utf8Error) -> ParseError {
-        ParseError::Utf8Error(error)
-    }
-}
-
-impl Error for ParseError {
-    fn description(&self) -> &str {
-        self.as_str()
-    }
-}
-
-fn indexes_of(needle: &str, haystack: &str) -> Option<(usize, usize)> {
-    let haystack_start = haystack.as_ptr() as usize;
-    let needle_start = needle.as_ptr() as usize;
-
-    if needle_start < haystack_start {
-        return None;
-    }
-
-    if (needle_start + needle.len()) > (haystack_start + haystack.len()) {
-        return None;
-    }
-
-    let start = needle_start - haystack_start;
-    let end = start + needle.len();
-    Some((start, end))
-}
-
-fn name_val_decoded(
-    name: &str,
-    val: &str,
-) -> Result<(CookieStr, CookieStr), ParseError> {
-    let decoded_name = percent_decode(name.as_bytes()).decode_utf8()?;
-    let decoded_value = percent_decode(val.as_bytes()).decode_utf8()?;
-    let name = CookieStr::Concrete(Cow::Owned(decoded_name.into_owned()));
-    let val = CookieStr::Concrete(Cow::Owned(decoded_value.into_owned()));
-
-    Ok((name, val))
-}
-
-// This function does the real parsing but _does not_ set the `cookie_string` in
-// the returned cookie object. This only exists so that the borrow to `s` is
-// returned at the end of the call, allowing the `cookie_string` field to be
-// set in the outer `parse` function.
-fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
-    let mut attributes = s.split(';');
-    let key_value = match attributes.next() {
-        Some(s) => s,
-        _ => panic!(),
-    };
-
-    // Determine the name = val.
-    let (name, value) = match key_value.find('=') {
-        Some(i) => (key_value[..i].trim(), key_value[(i + 1)..].trim()),
-        None => return Err(ParseError::MissingPair),
-    };
-
-    if name.is_empty() {
-        return Err(ParseError::EmptyName);
-    }
-
-    // Create a cookie with all of the defaults. We'll fill things in while we
-    // iterate through the parameters below.
-    let (name, value) = if decode {
-        name_val_decoded(name, value)?
-    } else {
-        let name_indexes = indexes_of(name, s).expect("name sub");
-        let value_indexes = indexes_of(value, s).expect("value sub");
-        let name = CookieStr::Indexed(name_indexes.0, name_indexes.1);
-        let value = CookieStr::Indexed(value_indexes.0, value_indexes.1);
-
-        (name, value)
-    };
-
-    let mut cookie = Cookie {
-        name,
-        value,
-        cookie_string: None,
-        expires: None,
-        max_age: None,
-        domain: None,
-        path: None,
-        secure: None,
-        http_only: None,
-        same_site: None,
-    };
-
-    for attr in attributes {
-        let (key, value) = match attr.find('=') {
-            Some(i) => (attr[..i].trim(), Some(attr[(i + 1)..].trim())),
-            None => (attr.trim(), None),
-        };
-
-        match (&*key.to_ascii_lowercase(), value) {
-            ("secure", _) => cookie.secure = Some(true),
-            ("httponly", _) => cookie.http_only = Some(true),
-            ("max-age", Some(v)) => {
-                // See RFC 6265 Section 5.2.2, negative values indicate that the
-                // earliest possible expiration time should be used, so set the
-                // max age as 0 seconds.
-                cookie.max_age = match v.parse() {
-                    Ok(val) if val <= 0 => Some(Duration::zero()),
-                    Ok(val) => {
-                        // Don't panic if the max age seconds is greater than what's supported by
-                        // `Duration`.
-                        let val = cmp::min(val, Duration::max_value().num_seconds());
-                        Some(Duration::seconds(val))
-                    }
-                    Err(_) => continue,
-                };
-            }
-            ("domain", Some(mut domain)) if !domain.is_empty() => {
-                if domain.starts_with('.') {
-                    domain = &domain[1..];
-                }
-
-                let (i, j) = indexes_of(domain, s).expect("domain sub");
-                cookie.domain = Some(CookieStr::Indexed(i, j));
-            }
-            ("path", Some(v)) => {
-                let (i, j) = indexes_of(v, s).expect("path sub");
-                cookie.path = Some(CookieStr::Indexed(i, j));
-            }
-            ("samesite", Some(v)) => {
-                if v.eq_ignore_ascii_case("strict") {
-                    cookie.same_site = Some(SameSite::Strict);
-                } else if v.eq_ignore_ascii_case("lax") {
-                    cookie.same_site = Some(SameSite::Lax);
-                } else {
-                    // We do nothing here, for now. When/if the `SameSite`
-                    // attribute becomes standard, the spec says that we should
-                    // ignore this cookie, i.e, fail to parse it, when an
-                    // invalid value is passed in. The draft is at
-                    // http://httpwg.org/http-extensions/draft-ietf-httpbis-cookie-same-site.html.
-                }
-            }
-            ("expires", Some(v)) => {
-                // Try strptime with three date formats according to
-                // http://tools.ietf.org/html/rfc2616#section-3.3.1. Try
-                // additional ones as encountered in the real world.
-                let tm = time::strptime(v, "%a, %d %b %Y %H:%M:%S %Z")
-                    .or_else(|_| time::strptime(v, "%A, %d-%b-%y %H:%M:%S %Z"))
-                    .or_else(|_| time::strptime(v, "%a, %d-%b-%Y %H:%M:%S %Z"))
-                    .or_else(|_| time::strptime(v, "%a %b %d %H:%M:%S %Y"));
-
-                if let Ok(time) = tm {
-                    cookie.expires = Some(time)
-                }
-            }
-            _ => {
-                // We're going to be permissive here. If we have no idea what
-                // this is, then it's something nonstandard. We're not going to
-                // store it (because it's not compliant), but we're also not
-                // going to emit an error.
-            }
-        }
-    }
-
-    Ok(cookie)
-}
-
-pub fn parse_cookie<'c, S>(cow: S, decode: bool) -> Result<Cookie<'c>, ParseError>
-where
-    S: Into<Cow<'c, str>>,
-{
-    let s = cow.into();
-    let mut cookie = parse_inner(&s, decode)?;
-    cookie.cookie_string = Some(s);
-    Ok(cookie)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{Cookie, SameSite};
-    use chrono::Duration;
-    use time::strptime;
-
-    macro_rules! assert_eq_parse {
-        ($string:expr, $expected:expr) => {
-            let cookie = match Cookie::parse($string) {
-                Ok(cookie) => cookie,
-                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
-            };
-
-            assert_eq!(cookie, $expected);
-        };
-    }
-
-    macro_rules! assert_ne_parse {
-        ($string:expr, $expected:expr) => {
-            let cookie = match Cookie::parse($string) {
-                Ok(cookie) => cookie,
-                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
-            };
-
-            assert_ne!(cookie, $expected);
-        };
-    }
-
-    #[test]
-    fn parse_same_site() {
-        let expected = Cookie::build("foo", "bar")
-            .same_site(SameSite::Lax)
-            .finish();
-
-        assert_eq_parse!("foo=bar; SameSite=Lax", expected);
-        assert_eq_parse!("foo=bar; SameSite=lax", expected);
-        assert_eq_parse!("foo=bar; SameSite=LAX", expected);
-        assert_eq_parse!("foo=bar; samesite=Lax", expected);
-        assert_eq_parse!("foo=bar; SAMESITE=Lax", expected);
-
-        let expected = Cookie::build("foo", "bar")
-            .same_site(SameSite::Strict)
-            .finish();
-
-        assert_eq_parse!("foo=bar; SameSite=Strict", expected);
-        assert_eq_parse!("foo=bar; SameSITE=Strict", expected);
-        assert_eq_parse!("foo=bar; SameSite=strict", expected);
-        assert_eq_parse!("foo=bar; SameSite=STrICT", expected);
-        assert_eq_parse!("foo=bar; SameSite=STRICT", expected);
-    }
-
-    #[test]
-    fn parse() {
-        assert!(Cookie::parse("bar").is_err());
-        assert!(Cookie::parse("=bar").is_err());
-        assert!(Cookie::parse(" =bar").is_err());
-        assert!(Cookie::parse("foo=").is_ok());
-
-        let expected = Cookie::build("foo", "bar=baz").finish();
-        assert_eq_parse!("foo=bar=baz", expected);
-
-        let mut expected = Cookie::build("foo", "bar").finish();
-        assert_eq_parse!("foo=bar", expected);
-        assert_eq_parse!("foo = bar", expected);
-        assert_eq_parse!(" foo=bar ", expected);
-        assert_eq_parse!(" foo=bar ;Domain=", expected);
-        assert_eq_parse!(" foo=bar ;Domain= ", expected);
-        assert_eq_parse!(" foo=bar ;Ignored", expected);
-
-        let mut unexpected = Cookie::build("foo", "bar").http_only(false).finish();
-        assert_ne_parse!(" foo=bar ;HttpOnly", unexpected);
-        assert_ne_parse!(" foo=bar; httponly", unexpected);
-
-        expected.set_http_only(true);
-        assert_eq_parse!(" foo=bar ;HttpOnly", expected);
-        assert_eq_parse!(" foo=bar ;httponly", expected);
-        assert_eq_parse!(" foo=bar ;HTTPONLY=whatever", expected);
-        assert_eq_parse!(" foo=bar ; sekure; HTTPONLY", expected);
-
-        expected.set_secure(true);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure=aaaa", expected);
-
-        unexpected.set_http_only(true);
-        unexpected.set_secure(true);
-        assert_ne_parse!(" foo=bar ;HttpOnly; skeure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; =secure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly;", unexpected);
-
-        unexpected.set_secure(false);
-        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
-
-        expected.set_max_age(Duration::zero());
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=0", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0 ", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=-1", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", expected);
-
-        expected.set_max_age(Duration::minutes(1));
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=60", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age =   60 ", expected);
-
-        expected.set_max_age(Duration::seconds(4));
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4", expected);
-        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 4 ", expected);
-
-        unexpected.set_secure(true);
-        unexpected.set_max_age(Duration::minutes(1));
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=122", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 38 ", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=51", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", unexpected);
-        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0", unexpected);
-
-        expected.set_path("/");
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/", expected);
-
-        expected.set_path("/foo");
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/foo", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path=/foo", expected);
-        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path = /foo", expected);
-
-        unexpected.set_max_age(Duration::seconds(4));
-        unexpected.set_path("/bar");
-        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", unexpected);
-        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/baz", unexpected);
-
-        expected.set_domain("www.foo.com");
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=www.foo.com",
-            expected
-        );
-
-        expected.set_domain("foo.com");
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com",
-            expected
-        );
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=FOO.COM",
-            expected
-        );
-
-        unexpected.set_path("/foo");
-        unexpected.set_domain("bar.com");
-        assert_ne_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com",
-            unexpected
-        );
-        assert_ne_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=FOO.COM",
-            unexpected
-        );
-
-        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
-        let expires = strptime(time_str, "%a, %d %b %Y %H:%M:%S %Z").unwrap();
-        expected.set_expires(expires);
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
-            expected
-        );
-
-        unexpected.set_domain("foo.com");
-        let bad_expires = strptime(time_str, "%a, %d %b %Y %H:%S:%M %Z").unwrap();
-        expected.set_expires(bad_expires);
-        assert_ne_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
-            unexpected
-        );
-    }
-
-    #[test]
-    fn odd_characters() {
-        let expected = Cookie::new("foo", "b%2Fr");
-        assert_eq_parse!("foo=b%2Fr", expected);
-    }
-
-    #[test]
-    fn odd_characters_encoded() {
-        let expected = Cookie::new("foo", "b/r");
-        let cookie = match Cookie::parse_encoded("foo=b%2Fr") {
-            Ok(cookie) => cookie,
-            Err(e) => panic!("Failed to parse: {:?}", e),
-        };
-
-        assert_eq!(cookie, expected);
-    }
-
-    #[test]
-    fn do_not_panic_on_large_max_ages() {
-        let max_seconds = Duration::max_value().num_seconds();
-        let expected = Cookie::build("foo", "bar").max_age(max_seconds).finish();
-        assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", max_seconds + 1), expected);
-    }
-}
--- a/actix-http/src/cookie/secure/key.rs
+++ b/actix-http/src/cookie/secure/key.rs
@@ -1,180 +0,0 @@
-use ring::digest::{Algorithm, SHA256};
-use ring::hkdf::expand;
-use ring::hmac::SigningKey;
-use ring::rand::{SecureRandom, SystemRandom};
-
-use super::private::KEY_LEN as PRIVATE_KEY_LEN;
-use super::signed::KEY_LEN as SIGNED_KEY_LEN;
-
-static HKDF_DIGEST: &Algorithm = &SHA256;
-const KEYS_INFO: &str = "COOKIE;SIGNED:HMAC-SHA256;PRIVATE:AEAD-AES-256-GCM";
-
-/// A cryptographic master key for use with `Signed` and/or `Private` jars.
-///
-/// This structure encapsulates secure, cryptographic keys for use with both
-/// [PrivateJar](struct.PrivateJar.html) and [SignedJar](struct.SignedJar.html).
-/// It can be derived from a single master key via
-/// [from_master](#method.from_master) or generated from a secure random source
-/// via [generate](#method.generate). A single instance of `Key` can be used for
-/// both a `PrivateJar` and a `SignedJar`.
-///
-/// This type is only available when the `secure` feature is enabled.
-#[derive(Clone)]
-pub struct Key {
-    signing_key: [u8; SIGNED_KEY_LEN],
-    encryption_key: [u8; PRIVATE_KEY_LEN],
-}
-
-impl Key {
-    /// Derives new signing/encryption keys from a master key.
-    ///
-    /// The master key must be at least 256-bits (32 bytes). For security, the
-    /// master key _must_ be cryptographically random. The keys are derived
-    /// deterministically from the master key.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `key` is less than 32 bytes in length.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// # /*
-    /// let master_key = { /* a cryptographically random key >= 32 bytes */ };
-    /// # */
-    /// # let master_key: &Vec<u8> = &(0..32).collect();
-    ///
-    /// let key = Key::from_master(master_key);
-    /// ```
-    pub fn from_master(key: &[u8]) -> Key {
-        if key.len() < 32 {
-            panic!(
-                "bad master key length: expected at least 32 bytes, found {}",
-                key.len()
-            );
-        }
-
-        // Expand the user's key into two.
-        let prk = SigningKey::new(HKDF_DIGEST, key);
-        let mut both_keys = [0; SIGNED_KEY_LEN + PRIVATE_KEY_LEN];
-        expand(&prk, KEYS_INFO.as_bytes(), &mut both_keys);
-
-        // Copy the keys into their respective arrays.
-        let mut signing_key = [0; SIGNED_KEY_LEN];
-        let mut encryption_key = [0; PRIVATE_KEY_LEN];
-        signing_key.copy_from_slice(&both_keys[..SIGNED_KEY_LEN]);
-        encryption_key.copy_from_slice(&both_keys[SIGNED_KEY_LEN..]);
-
-        Key {
-            signing_key,
-            encryption_key,
-        }
-    }
-
-    /// Generates signing/encryption keys from a secure, random source. Keys are
-    /// generated nondeterministically.
-    ///
-    /// # Panics
-    ///
-    /// Panics if randomness cannot be retrieved from the operating system. See
-    /// [try_generate](#method.try_generate) for a non-panicking version.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::generate();
-    /// ```
-    pub fn generate() -> Key {
-        Self::try_generate().expect("failed to generate `Key` from randomness")
-    }
-
-    /// Attempts to generate signing/encryption keys from a secure, random
-    /// source. Keys are generated nondeterministically. If randomness cannot be
-    /// retrieved from the underlying operating system, returns `None`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::try_generate();
-    /// ```
-    pub fn try_generate() -> Option<Key> {
-        let mut sign_key = [0; SIGNED_KEY_LEN];
-        let mut enc_key = [0; PRIVATE_KEY_LEN];
-
-        let rng = SystemRandom::new();
-        if rng.fill(&mut sign_key).is_err() || rng.fill(&mut enc_key).is_err() {
-            return None;
-        }
-
-        Some(Key {
-            signing_key: sign_key,
-            encryption_key: enc_key,
-        })
-    }
-
-    /// Returns the raw bytes of a key suitable for signing cookies.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::generate();
-    /// let signing_key = key.signing();
-    /// ```
-    pub fn signing(&self) -> &[u8] {
-        &self.signing_key[..]
-    }
-
-    /// Returns the raw bytes of a key suitable for encrypting cookies.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::Key;
-    ///
-    /// let key = Key::generate();
-    /// let encryption_key = key.encryption();
-    /// ```
-    pub fn encryption(&self) -> &[u8] {
-        &self.encryption_key[..]
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Key;
-
-    #[test]
-    fn deterministic_from_master() {
-        let master_key: Vec<u8> = (0..32).collect();
-
-        let key_a = Key::from_master(&master_key);
-        let key_b = Key::from_master(&master_key);
-
-        assert_eq!(key_a.signing(), key_b.signing());
-        assert_eq!(key_a.encryption(), key_b.encryption());
-        assert_ne!(key_a.encryption(), key_a.signing());
-
-        let master_key_2: Vec<u8> = (32..64).collect();
-        let key_2 = Key::from_master(&master_key_2);
-
-        assert_ne!(key_2.signing(), key_a.signing());
-        assert_ne!(key_2.encryption(), key_a.encryption());
-    }
-
-    #[test]
-    fn non_deterministic_generate() {
-        let key_a = Key::generate();
-        let key_b = Key::generate();
-
-        assert_ne!(key_a.signing(), key_b.signing());
-        assert_ne!(key_a.encryption(), key_b.encryption());
-    }
-}
--- a/actix-http/src/cookie/secure/macros.rs
+++ b/actix-http/src/cookie/secure/macros.rs
@@ -1,40 +0,0 @@
-#[cfg(test)]
-macro_rules! assert_simple_behaviour {
-    ($clear:expr, $secure:expr) => {{
-        assert_eq!($clear.iter().count(), 0);
-
-        $secure.add(Cookie::new("name", "val"));
-        assert_eq!($clear.iter().count(), 1);
-        assert_eq!($secure.get("name").unwrap().value(), "val");
-        assert_ne!($clear.get("name").unwrap().value(), "val");
-
-        $secure.add(Cookie::new("another", "two"));
-        assert_eq!($clear.iter().count(), 2);
-
-        $clear.remove(Cookie::named("another"));
-        assert_eq!($clear.iter().count(), 1);
-
-        $secure.remove(Cookie::named("name"));
-        assert_eq!($clear.iter().count(), 0);
-    }};
-}
-
-#[cfg(test)]
-macro_rules! assert_secure_behaviour {
-    ($clear:expr, $secure:expr) => {{
-        $secure.add(Cookie::new("secure", "secure"));
-        assert!($clear.get("secure").unwrap().value() != "secure");
-        assert!($secure.get("secure").unwrap().value() == "secure");
-
-        let mut cookie = $clear.get("secure").unwrap().clone();
-        let new_val = format!("{}l", cookie.value());
-        cookie.set_value(new_val);
-        $clear.add(cookie);
-        assert!($secure.get("secure").is_none());
-
-        let mut cookie = $clear.get("secure").unwrap().clone();
-        cookie.set_value("foobar");
-        $clear.add(cookie);
-        assert!($secure.get("secure").is_none());
-    }};
-}
--- a/actix-http/src/cookie/secure/mod.rs
+++ b/actix-http/src/cookie/secure/mod.rs
@@ -1,10 +0,0 @@
-//! Fork of https://github.com/alexcrichton/cookie-rs
-#[macro_use]
-mod macros;
-mod key;
-mod private;
-mod signed;
-
-pub use self::key::*;
-pub use self::private::*;
-pub use self::signed::*;
--- a/actix-http/src/cookie/secure/private.rs
+++ b/actix-http/src/cookie/secure/private.rs
@@ -1,269 +0,0 @@
-use std::str;
-
-use log::warn;
-use ring::aead::{open_in_place, seal_in_place, Aad, Algorithm, Nonce, AES_256_GCM};
-use ring::aead::{OpeningKey, SealingKey};
-use ring::rand::{SecureRandom, SystemRandom};
-
-use super::Key;
-use crate::cookie::{Cookie, CookieJar};
-
-// Keep these in sync, and keep the key len synced with the `private` docs as
-// well as the `KEYS_INFO` const in secure::Key.
-static ALGO: &Algorithm = &AES_256_GCM;
-const NONCE_LEN: usize = 12;
-pub const KEY_LEN: usize = 32;
-
-/// A child cookie jar that provides authenticated encryption for its cookies.
-///
-/// A _private_ child jar signs and encrypts all the cookies added to it and
-/// verifies and decrypts cookies retrieved from it. Any cookies stored in a
-/// `PrivateJar` are simultaneously assured confidentiality, integrity, and
-/// authenticity. In other words, clients cannot discover nor tamper with the
-/// contents of a cookie, nor can they fabricate cookie data.
-///
-/// This type is only available when the `secure` feature is enabled.
-pub struct PrivateJar<'a> {
-    parent: &'a mut CookieJar,
-    key: [u8; KEY_LEN],
-}
-
-impl<'a> PrivateJar<'a> {
-    /// Creates a new child `PrivateJar` with parent `parent` and key `key`.
-    /// This method is typically called indirectly via the `signed` method of
-    /// `CookieJar`.
-    #[doc(hidden)]
-    pub fn new(parent: &'a mut CookieJar, key: &Key) -> PrivateJar<'a> {
-        let mut key_array = [0u8; KEY_LEN];
-        key_array.copy_from_slice(key.encryption());
-        PrivateJar {
-            parent,
-            key: key_array,
-        }
-    }
-
-    /// Given a sealed value `str` and a key name `name`, where the nonce is
-    /// prepended to the original value and then both are Base64 encoded,
-    /// verifies and decrypts the sealed value and returns it. If there's a
-    /// problem, returns an `Err` with a string describing the issue.
-    fn unseal(&self, name: &str, value: &str) -> Result<String, &'static str> {
-        let mut data = base64::decode(value).map_err(|_| "bad base64 value")?;
-        if data.len() <= NONCE_LEN {
-            return Err("length of decoded data is <= NONCE_LEN");
-        }
-
-        let ad = Aad::from(name.as_bytes());
-        let key = OpeningKey::new(ALGO, &self.key).expect("opening key");
-        let (nonce, sealed) = data.split_at_mut(NONCE_LEN);
-        let nonce =
-            Nonce::try_assume_unique_for_key(nonce).expect("invalid length of `nonce`");
-        let unsealed = open_in_place(&key, nonce, ad, 0, sealed)
-            .map_err(|_| "invalid key/nonce/value: bad seal")?;
-
-        if let Ok(unsealed_utf8) = str::from_utf8(unsealed) {
-            Ok(unsealed_utf8.to_string())
-        } else {
-            warn!(
-                "Private cookie does not have utf8 content!
-It is likely the secret key used to encrypt them has been leaked.
-Please change it as soon as possible."
-            );
-            Err("bad unsealed utf8")
-        }
-    }
-
-    /// Returns a reference to the `Cookie` inside this jar with the name `name`
-    /// and authenticates and decrypts the cookie's value, returning a `Cookie`
-    /// with the decrypted value. If the cookie cannot be found, or the cookie
-    /// fails to authenticate or decrypt, `None` is returned.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut private_jar = jar.private(&key);
-    /// assert!(private_jar.get("name").is_none());
-    ///
-    /// private_jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(private_jar.get("name").unwrap().value(), "value");
-    /// ```
-    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
-        if let Some(cookie_ref) = self.parent.get(name) {
-            let mut cookie = cookie_ref.clone();
-            if let Ok(value) = self.unseal(name, cookie.value()) {
-                cookie.set_value(value);
-                return Some(cookie);
-            }
-        }
-
-        None
-    }
-
-    /// Adds `cookie` to the parent jar. The cookie's value is encrypted with
-    /// authenticated encryption assuring confidentiality, integrity, and
-    /// authenticity.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.private(&key).add(Cookie::new("name", "value"));
-    ///
-    /// assert_ne!(jar.get("name").unwrap().value(), "value");
-    /// assert_eq!(jar.private(&key).get("name").unwrap().value(), "value");
-    /// ```
-    pub fn add(&mut self, mut cookie: Cookie<'static>) {
-        self.encrypt_cookie(&mut cookie);
-
-        // Add the sealed cookie to the parent.
-        self.parent.add(cookie);
-    }
-
-    /// Adds an "original" `cookie` to parent jar. The cookie's value is
-    /// encrypted with authenticated encryption assuring confidentiality,
-    /// integrity, and authenticity. Adding an original cookie does not affect
-    /// the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
-    /// computation. This method is intended to be used to seed the cookie jar
-    /// with cookies received from a client's HTTP message.
-    ///
-    /// For accurate `delta` computations, this method should not be called
-    /// after calling `remove`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.private(&key).add_original(Cookie::new("name", "value"));
-    ///
-    /// assert_eq!(jar.iter().count(), 1);
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
-        self.encrypt_cookie(&mut cookie);
-
-        // Add the sealed cookie to the parent.
-        self.parent.add_original(cookie);
-    }
-
-    /// Encrypts the cookie's value with
-    /// authenticated encryption assuring confidentiality, integrity, and authenticity.
-    fn encrypt_cookie(&self, cookie: &mut Cookie) {
-        let name = cookie.name().as_bytes();
-        let value = cookie.value().as_bytes();
-        let data = encrypt_name_value(name, value, &self.key);
-
-        // Base64 encode the nonce and encrypted value.
-        let sealed_value = base64::encode(&data);
-        cookie.set_value(sealed_value);
-    }
-
-    /// Removes `cookie` from the parent jar.
-    ///
-    /// For correct removal, the passed in `cookie` must contain the same `path`
-    /// and `domain` as the cookie that was initially set.
-    ///
-    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
-    /// details.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut private_jar = jar.private(&key);
-    ///
-    /// private_jar.add(Cookie::new("name", "value"));
-    /// assert!(private_jar.get("name").is_some());
-    ///
-    /// private_jar.remove(Cookie::named("name"));
-    /// assert!(private_jar.get("name").is_none());
-    /// ```
-    pub fn remove(&mut self, cookie: Cookie<'static>) {
-        self.parent.remove(cookie);
-    }
-}
-
-fn encrypt_name_value(name: &[u8], value: &[u8], key: &[u8]) -> Vec<u8> {
-    // Create the `SealingKey` structure.
-    let key = SealingKey::new(ALGO, key).expect("sealing key creation");
-
-    // Create a vec to hold the [nonce | cookie value | overhead].
-    let overhead = ALGO.tag_len();
-    let mut data = vec![0; NONCE_LEN + value.len() + overhead];
-
-    // Randomly generate the nonce, then copy the cookie value as input.
-    let (nonce, in_out) = data.split_at_mut(NONCE_LEN);
-    SystemRandom::new()
-        .fill(nonce)
-        .expect("couldn't random fill nonce");
-    in_out[..value.len()].copy_from_slice(value);
-    let nonce =
-        Nonce::try_assume_unique_for_key(nonce).expect("invalid length of `nonce`");
-
-    // Use cookie's name as associated data to prevent value swapping.
-    let ad = Aad::from(name);
-
-    // Perform the actual sealing operation and get the output length.
-    let output_len =
-        seal_in_place(&key, nonce, ad, in_out, overhead).expect("in-place seal");
-
-    // Remove the overhead and return the sealed content.
-    data.truncate(NONCE_LEN + output_len);
-    data
-}
-
-#[cfg(test)]
-mod test {
-    use super::{encrypt_name_value, Cookie, CookieJar, Key};
-
-    #[test]
-    fn simple() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_simple_behaviour!(jar, jar.private(&key));
-    }
-
-    #[test]
-    fn private() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_secure_behaviour!(jar, jar.private(&key));
-    }
-
-    #[test]
-    fn non_utf8() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-
-        let name = "malicious";
-        let mut assert_non_utf8 = |value: &[u8]| {
-            let sealed = encrypt_name_value(name.as_bytes(), value, &key.encryption());
-            let encoded = base64::encode(&sealed);
-            assert_eq!(
-                jar.private(&key).unseal(name, &encoded),
-                Err("bad unsealed utf8")
-            );
-            jar.add(Cookie::new(name, encoded));
-            assert_eq!(jar.private(&key).get(name), None);
-        };
-
-        assert_non_utf8(&[0x72, 0xfb, 0xdf, 0x74]); // rûst in ISO/IEC 8859-1
-
-        let mut malicious =
-            String::from(r#"{"id":"abc123??%X","admin":true}"#).into_bytes();
-        malicious[8] |= 0b1100_0000;
-        malicious[9] |= 0b1100_0000;
-        assert_non_utf8(&malicious);
-    }
-}
--- a/actix-http/src/cookie/secure/signed.rs
+++ b/actix-http/src/cookie/secure/signed.rs
@@ -1,185 +0,0 @@
-use ring::digest::{Algorithm, SHA256};
-use ring::hmac::{sign, verify_with_own_key as verify, SigningKey};
-
-use super::Key;
-use crate::cookie::{Cookie, CookieJar};
-
-// Keep these in sync, and keep the key len synced with the `signed` docs as
-// well as the `KEYS_INFO` const in secure::Key.
-static HMAC_DIGEST: &Algorithm = &SHA256;
-const BASE64_DIGEST_LEN: usize = 44;
-pub const KEY_LEN: usize = 32;
-
-/// A child cookie jar that authenticates its cookies.
-///
-/// A _signed_ child jar signs all the cookies added to it and verifies cookies
-/// retrieved from it. Any cookies stored in a `SignedJar` are assured integrity
-/// and authenticity. In other words, clients cannot tamper with the contents of
-/// a cookie nor can they fabricate cookie values, but the data is visible in
-/// plaintext.
-///
-/// This type is only available when the `secure` feature is enabled.
-pub struct SignedJar<'a> {
-    parent: &'a mut CookieJar,
-    key: SigningKey,
-}
-
-impl<'a> SignedJar<'a> {
-    /// Creates a new child `SignedJar` with parent `parent` and key `key`. This
-    /// method is typically called indirectly via the `signed` method of
-    /// `CookieJar`.
-    #[doc(hidden)]
-    pub fn new(parent: &'a mut CookieJar, key: &Key) -> SignedJar<'a> {
-        SignedJar {
-            parent,
-            key: SigningKey::new(HMAC_DIGEST, key.signing()),
-        }
-    }
-
-    /// Given a signed value `str` where the signature is prepended to `value`,
-    /// verifies the signed value and returns it. If there's a problem, returns
-    /// an `Err` with a string describing the issue.
-    fn verify(&self, cookie_value: &str) -> Result<String, &'static str> {
-        if cookie_value.len() < BASE64_DIGEST_LEN {
-            return Err("length of value is <= BASE64_DIGEST_LEN");
-        }
-
-        let (digest_str, value) = cookie_value.split_at(BASE64_DIGEST_LEN);
-        let sig = base64::decode(digest_str).map_err(|_| "bad base64 digest")?;
-
-        verify(&self.key, value.as_bytes(), &sig)
-            .map(|_| value.to_string())
-            .map_err(|_| "value did not verify")
-    }
-
-    /// Returns a reference to the `Cookie` inside this jar with the name `name`
-    /// and verifies the authenticity and integrity of the cookie's value,
-    /// returning a `Cookie` with the authenticated value. If the cookie cannot
-    /// be found, or the cookie fails to verify, `None` is returned.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut signed_jar = jar.signed(&key);
-    /// assert!(signed_jar.get("name").is_none());
-    ///
-    /// signed_jar.add(Cookie::new("name", "value"));
-    /// assert_eq!(signed_jar.get("name").unwrap().value(), "value");
-    /// ```
-    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
-        if let Some(cookie_ref) = self.parent.get(name) {
-            let mut cookie = cookie_ref.clone();
-            if let Ok(value) = self.verify(cookie.value()) {
-                cookie.set_value(value);
-                return Some(cookie);
-            }
-        }
-
-        None
-    }
-
-    /// Adds `cookie` to the parent jar. The cookie's value is signed assuring
-    /// integrity and authenticity.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.signed(&key).add(Cookie::new("name", "value"));
-    ///
-    /// assert_ne!(jar.get("name").unwrap().value(), "value");
-    /// assert!(jar.get("name").unwrap().value().contains("value"));
-    /// assert_eq!(jar.signed(&key).get("name").unwrap().value(), "value");
-    /// ```
-    pub fn add(&mut self, mut cookie: Cookie<'static>) {
-        self.sign_cookie(&mut cookie);
-        self.parent.add(cookie);
-    }
-
-    /// Adds an "original" `cookie` to this jar. The cookie's value is signed
-    /// assuring integrity and authenticity. Adding an original cookie does not
-    /// affect the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
-    /// computation. This method is intended to be used to seed the cookie jar
-    /// with cookies received from a client's HTTP message.
-    ///
-    /// For accurate `delta` computations, this method should not be called
-    /// after calling `remove`.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// jar.signed(&key).add_original(Cookie::new("name", "value"));
-    ///
-    /// assert_eq!(jar.iter().count(), 1);
-    /// assert_eq!(jar.delta().count(), 0);
-    /// ```
-    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
-        self.sign_cookie(&mut cookie);
-        self.parent.add_original(cookie);
-    }
-
-    /// Signs the cookie's value assuring integrity and authenticity.
-    fn sign_cookie(&self, cookie: &mut Cookie) {
-        let digest = sign(&self.key, cookie.value().as_bytes());
-        let mut new_value = base64::encode(digest.as_ref());
-        new_value.push_str(cookie.value());
-        cookie.set_value(new_value);
-    }
-
-    /// Removes `cookie` from the parent jar.
-    ///
-    /// For correct removal, the passed in `cookie` must contain the same `path`
-    /// and `domain` as the cookie that was initially set.
-    ///
-    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
-    /// details.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use actix_http::cookie::{CookieJar, Cookie, Key};
-    ///
-    /// let key = Key::generate();
-    /// let mut jar = CookieJar::new();
-    /// let mut signed_jar = jar.signed(&key);
-    ///
-    /// signed_jar.add(Cookie::new("name", "value"));
-    /// assert!(signed_jar.get("name").is_some());
-    ///
-    /// signed_jar.remove(Cookie::named("name"));
-    /// assert!(signed_jar.get("name").is_none());
-    /// ```
-    pub fn remove(&mut self, cookie: Cookie<'static>) {
-        self.parent.remove(cookie);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::{Cookie, CookieJar, Key};
-
-    #[test]
-    fn simple() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_simple_behaviour!(jar, jar.signed(&key));
-    }
-
-    #[test]
-    fn private() {
-        let key = Key::generate();
-        let mut jar = CookieJar::new();
-        assert_secure_behaviour!(jar, jar.signed(&key));
-    }
-}
--- a/actix-http/src/encoding/decoder.rs
+++ b/actix-http/src/encoding/decoder.rs
@@ -1,227 +0,0 @@
-use std::io::{self, Write};
-
-use actix_threadpool::{run, CpuFuture};
-#[cfg(feature = "brotli")]
-use brotli2::write::BrotliDecoder;
-use bytes::Bytes;
-#[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-use flate2::write::{GzDecoder, ZlibDecoder};
-use futures::{try_ready, Async, Future, Poll, Stream};
-
-use super::Writer;
-use crate::error::PayloadError;
-use crate::http::header::{ContentEncoding, HeaderMap, CONTENT_ENCODING};
-
-const INPLACE: usize = 2049;
-
-pub struct Decoder<S> {
-    decoder: Option<ContentDecoder>,
-    stream: S,
-    eof: bool,
-    fut: Option<CpuFuture<(Option<Bytes>, ContentDecoder), io::Error>>,
-}
-
-impl<S> Decoder<S>
-where
-    S: Stream<Item = Bytes, Error = PayloadError>,
-{
-    /// Construct a decoder.
-    #[inline]
-    pub fn new(stream: S, encoding: ContentEncoding) -> Decoder<S> {
-        let decoder = match encoding {
-            #[cfg(feature = "brotli")]
-            ContentEncoding::Br => Some(ContentDecoder::Br(Box::new(
-                BrotliDecoder::new(Writer::new()),
-            ))),
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoding::Deflate => Some(ContentDecoder::Deflate(Box::new(
-                ZlibDecoder::new(Writer::new()),
-            ))),
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoding::Gzip => Some(ContentDecoder::Gzip(Box::new(
-                GzDecoder::new(Writer::new()),
-            ))),
-            _ => None,
-        };
-        Decoder {
-            decoder,
-            stream,
-            fut: None,
-            eof: false,
-        }
-    }
-
-    /// Construct decoder based on headers.
-    #[inline]
-    pub fn from_headers(stream: S, headers: &HeaderMap) -> Decoder<S> {
-        // check content-encoding
-        let encoding = if let Some(enc) = headers.get(&CONTENT_ENCODING) {
-            if let Ok(enc) = enc.to_str() {
-                ContentEncoding::from(enc)
-            } else {
-                ContentEncoding::Identity
-            }
-        } else {
-            ContentEncoding::Identity
-        };
-
-        Self::new(stream, encoding)
-    }
-}
-
-impl<S> Stream for Decoder<S>
-where
-    S: Stream<Item = Bytes, Error = PayloadError>,
-{
-    type Item = Bytes;
-    type Error = PayloadError;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        loop {
-            if let Some(ref mut fut) = self.fut {
-                let (chunk, decoder) = try_ready!(fut.poll());
-                self.decoder = Some(decoder);
-                self.fut.take();
-                if let Some(chunk) = chunk {
-                    return Ok(Async::Ready(Some(chunk)));
-                }
-            }
-
-            if self.eof {
-                return Ok(Async::Ready(None));
-            }
-
-            match self.stream.poll()? {
-                Async::Ready(Some(chunk)) => {
-                    if let Some(mut decoder) = self.decoder.take() {
-                        if chunk.len() < INPLACE {
-                            let chunk = decoder.feed_data(chunk)?;
-                            self.decoder = Some(decoder);
-                            if let Some(chunk) = chunk {
-                                return Ok(Async::Ready(Some(chunk)));
-                            }
-                        } else {
-                            self.fut = Some(run(move || {
-                                let chunk = decoder.feed_data(chunk)?;
-                                Ok((chunk, decoder))
-                            }));
-                        }
-                        continue;
-                    } else {
-                        return Ok(Async::Ready(Some(chunk)));
-                    }
-                }
-                Async::Ready(None) => {
-                    self.eof = true;
-                    return if let Some(mut decoder) = self.decoder.take() {
-                        Ok(Async::Ready(decoder.feed_eof()?))
-                    } else {
-                        Ok(Async::Ready(None))
-                    };
-                }
-                Async::NotReady => break,
-            }
-        }
-        Ok(Async::NotReady)
-    }
-}
-
-enum ContentDecoder {
-    #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-    Deflate(Box<ZlibDecoder<Writer>>),
-    #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-    Gzip(Box<GzDecoder<Writer>>),
-    #[cfg(feature = "brotli")]
-    Br(Box<BrotliDecoder<Writer>>),
-}
-
-impl ContentDecoder {
-    #[allow(unreachable_patterns)]
-    fn feed_eof(&mut self) -> io::Result<Option<Bytes>> {
-        match self {
-            #[cfg(feature = "brotli")]
-            ContentDecoder::Br(ref mut decoder) => match decoder.finish() {
-                Ok(mut writer) => {
-                    let b = writer.take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentDecoder::Gzip(ref mut decoder) => match decoder.try_finish() {
-                Ok(_) => {
-                    let b = decoder.get_mut().take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentDecoder::Deflate(ref mut decoder) => match decoder.try_finish() {
-                Ok(_) => {
-                    let b = decoder.get_mut().take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-            _ => Ok(None),
-        }
-    }
-
-    #[allow(unreachable_patterns)]
-    fn feed_data(&mut self, data: Bytes) -> io::Result<Option<Bytes>> {
-        match self {
-            #[cfg(feature = "brotli")]
-            ContentDecoder::Br(ref mut decoder) => match decoder.write_all(&data) {
-                Ok(_) => {
-                    decoder.flush()?;
-                    let b = decoder.get_mut().take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentDecoder::Gzip(ref mut decoder) => match decoder.write_all(&data) {
-                Ok(_) => {
-                    decoder.flush()?;
-                    let b = decoder.get_mut().take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentDecoder::Deflate(ref mut decoder) => match decoder.write_all(&data) {
-                Ok(_) => {
-                    decoder.flush()?;
-                    let b = decoder.get_mut().take();
-                    if !b.is_empty() {
-                        Ok(Some(b))
-                    } else {
-                        Ok(None)
-                    }
-                }
-                Err(e) => Err(e),
-            },
-            _ => Ok(Some(data)),
-        }
-    }
-}
--- a/actix-http/src/encoding/encoder.rs
+++ b/actix-http/src/encoding/encoder.rs
@@ -1,260 +0,0 @@
-//! Stream encoder
-use std::io::{self, Write};
-
-use actix_threadpool::{run, CpuFuture};
-#[cfg(feature = "brotli")]
-use brotli2::write::BrotliEncoder;
-use bytes::Bytes;
-#[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-use flate2::write::{GzEncoder, ZlibEncoder};
-use futures::{Async, Future, Poll};
-
-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
-use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
-use crate::http::{HeaderValue, HttpTryFrom, StatusCode};
-use crate::{Error, ResponseHead};
-
-use super::Writer;
-
-const INPLACE: usize = 2049;
-
-pub struct Encoder<B> {
-    eof: bool,
-    body: EncoderBody<B>,
-    encoder: Option<ContentEncoder>,
-    fut: Option<CpuFuture<ContentEncoder, io::Error>>,
-}
-
-impl<B: MessageBody> Encoder<B> {
-    pub fn response(
-        encoding: ContentEncoding,
-        head: &mut ResponseHead,
-        body: ResponseBody<B>,
-    ) -> ResponseBody<Encoder<B>> {
-        let can_encode = !(head.headers().contains_key(&CONTENT_ENCODING)
-            || head.status == StatusCode::SWITCHING_PROTOCOLS
-            || head.status == StatusCode::NO_CONTENT
-            || encoding == ContentEncoding::Identity
-            || encoding == ContentEncoding::Auto);
-
-        let body = match body {
-            ResponseBody::Other(b) => match b {
-                Body::None => return ResponseBody::Other(Body::None),
-                Body::Empty => return ResponseBody::Other(Body::Empty),
-                Body::Bytes(buf) => {
-                    if can_encode {
-                        EncoderBody::Bytes(buf)
-                    } else {
-                        return ResponseBody::Other(Body::Bytes(buf));
-                    }
-                }
-                Body::Message(stream) => EncoderBody::BoxedStream(stream),
-            },
-            ResponseBody::Body(stream) => EncoderBody::Stream(stream),
-        };
-
-        if can_encode {
-            // Modify response body only if encoder is not None
-            if let Some(enc) = ContentEncoder::encoder(encoding) {
-                update_head(encoding, head);
-                head.no_chunking(false);
-                return ResponseBody::Body(Encoder {
-                    body,
-                    eof: false,
-                    fut: None,
-                    encoder: Some(enc),
-                });
-            }
-        }
-        ResponseBody::Body(Encoder {
-            body,
-            eof: false,
-            fut: None,
-            encoder: None,
-        })
-    }
-}
-
-enum EncoderBody<B> {
-    Bytes(Bytes),
-    Stream(B),
-    BoxedStream(Box<dyn MessageBody>),
-}
-
-impl<B: MessageBody> MessageBody for Encoder<B> {
-    fn size(&self) -> BodySize {
-        if self.encoder.is_none() {
-            match self.body {
-                EncoderBody::Bytes(ref b) => b.size(),
-                EncoderBody::Stream(ref b) => b.size(),
-                EncoderBody::BoxedStream(ref b) => b.size(),
-            }
-        } else {
-            BodySize::Stream
-        }
-    }
-
-    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
-        loop {
-            if self.eof {
-                return Ok(Async::Ready(None));
-            }
-
-            if let Some(ref mut fut) = self.fut {
-                let mut encoder = futures::try_ready!(fut.poll());
-                let chunk = encoder.take();
-                self.encoder = Some(encoder);
-                self.fut.take();
-                if !chunk.is_empty() {
-                    return Ok(Async::Ready(Some(chunk)));
-                }
-            }
-
-            let result = match self.body {
-                EncoderBody::Bytes(ref mut b) => {
-                    if b.is_empty() {
-                        Async::Ready(None)
-                    } else {
-                        Async::Ready(Some(std::mem::replace(b, Bytes::new())))
-                    }
-                }
-                EncoderBody::Stream(ref mut b) => b.poll_next()?,
-                EncoderBody::BoxedStream(ref mut b) => b.poll_next()?,
-            };
-            match result {
-                Async::NotReady => return Ok(Async::NotReady),
-                Async::Ready(Some(chunk)) => {
-                    if let Some(mut encoder) = self.encoder.take() {
-                        if chunk.len() < INPLACE {
-                            encoder.write(&chunk)?;
-                            let chunk = encoder.take();
-                            self.encoder = Some(encoder);
-                            if !chunk.is_empty() {
-                                return Ok(Async::Ready(Some(chunk)));
-                            }
-                        } else {
-                            self.fut = Some(run(move || {
-                                encoder.write(&chunk)?;
-                                Ok(encoder)
-                            }));
-                        }
-                    } else {
-                        return Ok(Async::Ready(Some(chunk)));
-                    }
-                }
-                Async::Ready(None) => {
-                    if let Some(encoder) = self.encoder.take() {
-                        let chunk = encoder.finish()?;
-                        if chunk.is_empty() {
-                            return Ok(Async::Ready(None));
-                        } else {
-                            self.eof = true;
-                            return Ok(Async::Ready(Some(chunk)));
-                        }
-                    } else {
-                        return Ok(Async::Ready(None));
-                    }
-                }
-            }
-        }
-    }
-}
-
-fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
-    head.headers_mut().insert(
-        CONTENT_ENCODING,
-        HeaderValue::try_from(Bytes::from_static(encoding.as_str().as_bytes())).unwrap(),
-    );
-}
-
-enum ContentEncoder {
-    #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-    Deflate(ZlibEncoder<Writer>),
-    #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-    Gzip(GzEncoder<Writer>),
-    #[cfg(feature = "brotli")]
-    Br(BrotliEncoder<Writer>),
-}
-
-impl ContentEncoder {
-    fn encoder(encoding: ContentEncoding) -> Option<Self> {
-        match encoding {
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoding::Deflate => Some(ContentEncoder::Deflate(ZlibEncoder::new(
-                Writer::new(),
-                flate2::Compression::fast(),
-            ))),
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoding::Gzip => Some(ContentEncoder::Gzip(GzEncoder::new(
-                Writer::new(),
-                flate2::Compression::fast(),
-            ))),
-            #[cfg(feature = "brotli")]
-            ContentEncoding::Br => {
-                Some(ContentEncoder::Br(BrotliEncoder::new(Writer::new(), 3)))
-            }
-            _ => None,
-        }
-    }
-
-    #[inline]
-    pub(crate) fn take(&mut self) -> Bytes {
-        match *self {
-            #[cfg(feature = "brotli")]
-            ContentEncoder::Br(ref mut encoder) => encoder.get_mut().take(),
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoder::Deflate(ref mut encoder) => encoder.get_mut().take(),
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoder::Gzip(ref mut encoder) => encoder.get_mut().take(),
-        }
-    }
-
-    fn finish(self) -> Result<Bytes, io::Error> {
-        match self {
-            #[cfg(feature = "brotli")]
-            ContentEncoder::Br(encoder) => match encoder.finish() {
-                Ok(writer) => Ok(writer.buf.freeze()),
-                Err(err) => Err(err),
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoder::Gzip(encoder) => match encoder.finish() {
-                Ok(writer) => Ok(writer.buf.freeze()),
-                Err(err) => Err(err),
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoder::Deflate(encoder) => match encoder.finish() {
-                Ok(writer) => Ok(writer.buf.freeze()),
-                Err(err) => Err(err),
-            },
-        }
-    }
-
-    fn write(&mut self, data: &[u8]) -> Result<(), io::Error> {
-        match *self {
-            #[cfg(feature = "brotli")]
-            ContentEncoder::Br(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding br encoding: {}", err);
-                    Err(err)
-                }
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding gzip encoding: {}", err);
-                    Err(err)
-                }
-            },
-            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
-            ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
-                Ok(_) => Ok(()),
-                Err(err) => {
-                    trace!("Error decoding deflate encoding: {}", err);
-                    Err(err)
-                }
-            },
-        }
-    }
-}
--- a/actix-http/src/encoding/mod.rs
+++ b/actix-http/src/encoding/mod.rs
@@ -1,35 +0,0 @@
-//! Content-Encoding support
-use std::io;
-
-use bytes::{Bytes, BytesMut};
-
-mod decoder;
-mod encoder;
-
-pub use self::decoder::Decoder;
-pub use self::encoder::Encoder;
-
-pub(self) struct Writer {
-    buf: BytesMut,
-}
-
-impl Writer {
-    fn new() -> Writer {
-        Writer {
-            buf: BytesMut::with_capacity(8192),
-        }
-    }
-    fn take(&mut self) -> Bytes {
-        self.buf.take().freeze()
-    }
-}
-
-impl io::Write for Writer {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.buf.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
--- a/actix-http/src/extensions.rs
+++ b/actix-http/src/extensions.rs
@@ -1,91 +0,0 @@
-use std::any::{Any, TypeId};
-use std::fmt;
-
-use hashbrown::HashMap;
-
-#[derive(Default)]
-/// A type map of request extensions.
-pub struct Extensions {
-    map: HashMap<TypeId, Box<dyn Any>>,
-}
-
-impl Extensions {
-    /// Create an empty `Extensions`.
-    #[inline]
-    pub fn new() -> Extensions {
-        Extensions {
-            map: HashMap::default(),
-        }
-    }
-
-    /// Insert a type into this `Extensions`.
-    ///
-    /// If a extension of this type already existed, it will
-    /// be returned.
-    pub fn insert<T: 'static>(&mut self, val: T) {
-        self.map.insert(TypeId::of::<T>(), Box::new(val));
-    }
-
-    /// Check if container contains entry
-    pub fn contains<T: 'static>(&self) -> bool {
-        self.map.get(&TypeId::of::<T>()).is_some()
-    }
-
-    /// Get a reference to a type previously inserted on this `Extensions`.
-    pub fn get<T: 'static>(&self) -> Option<&T> {
-        self.map
-            .get(&TypeId::of::<T>())
-            .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
-    }
-
-    /// Get a mutable reference to a type previously inserted on this `Extensions`.
-    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
-        self.map
-            .get_mut(&TypeId::of::<T>())
-            .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
-    }
-
-    /// Remove a type from this `Extensions`.
-    ///
-    /// If a extension of this type existed, it will be returned.
-    pub fn remove<T: 'static>(&mut self) -> Option<T> {
-        self.map.remove(&TypeId::of::<T>()).and_then(|boxed| {
-            (boxed as Box<dyn Any + 'static>)
-                .downcast()
-                .ok()
-                .map(|boxed| *boxed)
-        })
-    }
-
-    /// Clear the `Extensions` of all inserted extensions.
-    #[inline]
-    pub fn clear(&mut self) {
-        self.map.clear();
-    }
-}
-
-impl fmt::Debug for Extensions {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("Extensions").finish()
-    }
-}
-
-#[test]
-fn test_extensions() {
-    #[derive(Debug, PartialEq)]
-    struct MyType(i32);
-
-    let mut extensions = Extensions::new();
-
-    extensions.insert(5i32);
-    extensions.insert(MyType(10));
-
-    assert_eq!(extensions.get(), Some(&5i32));
-    assert_eq!(extensions.get_mut(), Some(&mut 5i32));
-
-    assert_eq!(extensions.remove::<i32>(), Some(5i32));
-    assert!(extensions.get::<i32>().is_none());
-
-    assert_eq!(extensions.get::<bool>(), None);
-    assert_eq!(extensions.get(), Some(&MyType(10)));
-}
--- a/actix-http/src/h1/client.rs
+++ b/actix-http/src/h1/client.rs
@@ -1,251 +0,0 @@
-#![allow(unused_imports, unused_variables, dead_code)]
-use std::io::{self, Write};
-use std::rc::Rc;
-
-use actix_codec::{Decoder, Encoder};
-use bitflags::bitflags;
-use bytes::{BufMut, Bytes, BytesMut};
-use http::header::{
-    HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING, UPGRADE,
-};
-use http::{Method, Version};
-
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
-use super::{decoder, encoder, reserve_readbuf};
-use super::{Message, MessageType};
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::error::{ParseError, PayloadError};
-use crate::header::HeaderMap;
-use crate::helpers;
-use crate::message::{
-    ConnectionType, Head, MessagePool, RequestHead, RequestHeadType, ResponseHead,
-};
-
-bitflags! {
-    struct Flags: u8 {
-        const HEAD              = 0b0000_0001;
-        const KEEPALIVE_ENABLED = 0b0000_1000;
-        const STREAM            = 0b0001_0000;
-    }
-}
-
-const AVERAGE_HEADER_SIZE: usize = 30;
-
-/// HTTP/1 Codec
-pub struct ClientCodec {
-    inner: ClientCodecInner,
-}
-
-/// HTTP/1 Payload Codec
-pub struct ClientPayloadCodec {
-    inner: ClientCodecInner,
-}
-
-struct ClientCodecInner {
-    config: ServiceConfig,
-    decoder: decoder::MessageDecoder<ResponseHead>,
-    payload: Option<PayloadDecoder>,
-    version: Version,
-    ctype: ConnectionType,
-
-    // encoder part
-    flags: Flags,
-    headers_size: u32,
-    encoder: encoder::MessageEncoder<RequestHeadType>,
-}
-
-impl Default for ClientCodec {
-    fn default() -> Self {
-        ClientCodec::new(ServiceConfig::default())
-    }
-}
-
-impl ClientCodec {
-    /// Create HTTP/1 codec.
-    ///
-    /// `keepalive_enabled` how response `connection` header get generated.
-    pub fn new(config: ServiceConfig) -> Self {
-        let flags = if config.keep_alive_enabled() {
-            Flags::KEEPALIVE_ENABLED
-        } else {
-            Flags::empty()
-        };
-        ClientCodec {
-            inner: ClientCodecInner {
-                config,
-                decoder: decoder::MessageDecoder::default(),
-                payload: None,
-                version: Version::HTTP_11,
-                ctype: ConnectionType::Close,
-
-                flags,
-                headers_size: 0,
-                encoder: encoder::MessageEncoder::default(),
-            },
-        }
-    }
-
-    /// Check if request is upgrade
-    pub fn upgrade(&self) -> bool {
-        self.inner.ctype == ConnectionType::Upgrade
-    }
-
-    /// Check if last response is keep-alive
-    pub fn keepalive(&self) -> bool {
-        self.inner.ctype == ConnectionType::KeepAlive
-    }
-
-    /// Check last request's message type
-    pub fn message_type(&self) -> MessageType {
-        if self.inner.flags.contains(Flags::STREAM) {
-            MessageType::Stream
-        } else if self.inner.payload.is_none() {
-            MessageType::None
-        } else {
-            MessageType::Payload
-        }
-    }
-
-    /// Convert message codec to a payload codec
-    pub fn into_payload_codec(self) -> ClientPayloadCodec {
-        ClientPayloadCodec { inner: self.inner }
-    }
-}
-
-impl ClientPayloadCodec {
-    /// Check if last response is keep-alive
-    pub fn keepalive(&self) -> bool {
-        self.inner.ctype == ConnectionType::KeepAlive
-    }
-
-    /// Transform payload codec to a message codec
-    pub fn into_message_codec(self) -> ClientCodec {
-        ClientCodec { inner: self.inner }
-    }
-}
-
-impl Decoder for ClientCodec {
-    type Item = ResponseHead;
-    type Error = ParseError;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        debug_assert!(!self.inner.payload.is_some(), "Payload decoder is set");
-
-        if let Some((req, payload)) = self.inner.decoder.decode(src)? {
-            if let Some(ctype) = req.ctype() {
-                // do not use peer's keep-alive
-                self.inner.ctype = if ctype == ConnectionType::KeepAlive {
-                    self.inner.ctype
-                } else {
-                    ctype
-                };
-            }
-
-            if !self.inner.flags.contains(Flags::HEAD) {
-                match payload {
-                    PayloadType::None => self.inner.payload = None,
-                    PayloadType::Payload(pl) => self.inner.payload = Some(pl),
-                    PayloadType::Stream(pl) => {
-                        self.inner.payload = Some(pl);
-                        self.inner.flags.insert(Flags::STREAM);
-                    }
-                }
-            } else {
-                self.inner.payload = None;
-            }
-            reserve_readbuf(src);
-            Ok(Some(req))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl Decoder for ClientPayloadCodec {
-    type Item = Option<Bytes>;
-    type Error = PayloadError;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        debug_assert!(
-            self.inner.payload.is_some(),
-            "Payload decoder is not specified"
-        );
-
-        Ok(match self.inner.payload.as_mut().unwrap().decode(src)? {
-            Some(PayloadItem::Chunk(chunk)) => {
-                reserve_readbuf(src);
-                Some(Some(chunk))
-            }
-            Some(PayloadItem::Eof) => {
-                self.inner.payload.take();
-                Some(None)
-            }
-            None => None,
-        })
-    }
-}
-
-impl Encoder for ClientCodec {
-    type Item = Message<(RequestHeadType, BodySize)>;
-    type Error = io::Error;
-
-    fn encode(
-        &mut self,
-        item: Self::Item,
-        dst: &mut BytesMut,
-    ) -> Result<(), Self::Error> {
-        match item {
-            Message::Item((mut head, length)) => {
-                let inner = &mut self.inner;
-                inner.version = head.as_ref().version;
-                inner
-                    .flags
-                    .set(Flags::HEAD, head.as_ref().method == Method::HEAD);
-
-                // connection status
-                inner.ctype = match head.as_ref().connection_type() {
-                    ConnectionType::KeepAlive => {
-                        if inner.flags.contains(Flags::KEEPALIVE_ENABLED) {
-                            ConnectionType::KeepAlive
-                        } else {
-                            ConnectionType::Close
-                        }
-                    }
-                    ConnectionType::Upgrade => ConnectionType::Upgrade,
-                    ConnectionType::Close => ConnectionType::Close,
-                };
-
-                inner.encoder.encode(
-                    dst,
-                    &mut head,
-                    false,
-                    false,
-                    inner.version,
-                    length,
-                    inner.ctype,
-                    &inner.config,
-                )?;
-            }
-            Message::Chunk(Some(bytes)) => {
-                self.inner.encoder.encode_chunk(bytes.as_ref(), dst)?;
-            }
-            Message::Chunk(None) => {
-                self.inner.encoder.encode_eof(dst)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-pub struct Writer<'a>(pub &'a mut BytesMut);
-
-impl<'a> io::Write for Writer<'a> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
--- a/actix-http/src/h1/codec.rs
+++ b/actix-http/src/h1/codec.rs
@@ -1,253 +0,0 @@
-#![allow(unused_imports, unused_variables, dead_code)]
-use std::io::Write;
-use std::{fmt, io, net};
-
-use actix_codec::{Decoder, Encoder};
-use bitflags::bitflags;
-use bytes::{BufMut, Bytes, BytesMut};
-use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use http::{Method, StatusCode, Version};
-
-use super::decoder::{PayloadDecoder, PayloadItem, PayloadType};
-use super::{decoder, encoder};
-use super::{Message, MessageType};
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::error::ParseError;
-use crate::helpers;
-use crate::message::{ConnectionType, Head, ResponseHead};
-use crate::request::Request;
-use crate::response::Response;
-
-bitflags! {
-    struct Flags: u8 {
-        const HEAD              = 0b0000_0001;
-        const KEEPALIVE_ENABLED = 0b0000_0010;
-        const STREAM            = 0b0000_0100;
-    }
-}
-
-const AVERAGE_HEADER_SIZE: usize = 30;
-
-/// HTTP/1 Codec
-pub struct Codec {
-    config: ServiceConfig,
-    decoder: decoder::MessageDecoder<Request>,
-    payload: Option<PayloadDecoder>,
-    version: Version,
-    ctype: ConnectionType,
-
-    // encoder part
-    flags: Flags,
-    encoder: encoder::MessageEncoder<Response<()>>,
-}
-
-impl Default for Codec {
-    fn default() -> Self {
-        Codec::new(ServiceConfig::default())
-    }
-}
-
-impl fmt::Debug for Codec {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "h1::Codec({:?})", self.flags)
-    }
-}
-
-impl Codec {
-    /// Create HTTP/1 codec.
-    ///
-    /// `keepalive_enabled` how response `connection` header get generated.
-    pub fn new(config: ServiceConfig) -> Self {
-        let flags = if config.keep_alive_enabled() {
-            Flags::KEEPALIVE_ENABLED
-        } else {
-            Flags::empty()
-        };
-        Codec {
-            config,
-            flags,
-            decoder: decoder::MessageDecoder::default(),
-            payload: None,
-            version: Version::HTTP_11,
-            ctype: ConnectionType::Close,
-            encoder: encoder::MessageEncoder::default(),
-        }
-    }
-
-    #[inline]
-    /// Check if request is upgrade
-    pub fn upgrade(&self) -> bool {
-        self.ctype == ConnectionType::Upgrade
-    }
-
-    #[inline]
-    /// Check if last response is keep-alive
-    pub fn keepalive(&self) -> bool {
-        self.ctype == ConnectionType::KeepAlive
-    }
-
-    #[inline]
-    /// Check if keep-alive enabled on server level
-    pub fn keepalive_enabled(&self) -> bool {
-        self.flags.contains(Flags::KEEPALIVE_ENABLED)
-    }
-
-    #[inline]
-    /// Check last request's message type
-    pub fn message_type(&self) -> MessageType {
-        if self.flags.contains(Flags::STREAM) {
-            MessageType::Stream
-        } else if self.payload.is_none() {
-            MessageType::None
-        } else {
-            MessageType::Payload
-        }
-    }
-
-    #[inline]
-    pub fn config(&self) -> &ServiceConfig {
-        &self.config
-    }
-}
-
-impl Decoder for Codec {
-    type Item = Message<Request>;
-    type Error = ParseError;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        if self.payload.is_some() {
-            Ok(match self.payload.as_mut().unwrap().decode(src)? {
-                Some(PayloadItem::Chunk(chunk)) => Some(Message::Chunk(Some(chunk))),
-                Some(PayloadItem::Eof) => {
-                    self.payload.take();
-                    Some(Message::Chunk(None))
-                }
-                None => None,
-            })
-        } else if let Some((req, payload)) = self.decoder.decode(src)? {
-            let head = req.head();
-            self.flags.set(Flags::HEAD, head.method == Method::HEAD);
-            self.version = head.version;
-            self.ctype = head.connection_type();
-            if self.ctype == ConnectionType::KeepAlive
-                && !self.flags.contains(Flags::KEEPALIVE_ENABLED)
-            {
-                self.ctype = ConnectionType::Close
-            }
-            match payload {
-                PayloadType::None => self.payload = None,
-                PayloadType::Payload(pl) => self.payload = Some(pl),
-                PayloadType::Stream(pl) => {
-                    self.payload = Some(pl);
-                    self.flags.insert(Flags::STREAM);
-                }
-            }
-            Ok(Some(Message::Item(req)))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl Encoder for Codec {
-    type Item = Message<(Response<()>, BodySize)>;
-    type Error = io::Error;
-
-    fn encode(
-        &mut self,
-        item: Self::Item,
-        dst: &mut BytesMut,
-    ) -> Result<(), Self::Error> {
-        match item {
-            Message::Item((mut res, length)) => {
-                // set response version
-                res.head_mut().version = self.version;
-
-                // connection status
-                self.ctype = if let Some(ct) = res.head().ctype() {
-                    if ct == ConnectionType::KeepAlive {
-                        self.ctype
-                    } else {
-                        ct
-                    }
-                } else {
-                    self.ctype
-                };
-
-                // encode message
-                let len = dst.len();
-                self.encoder.encode(
-                    dst,
-                    &mut res,
-                    self.flags.contains(Flags::HEAD),
-                    self.flags.contains(Flags::STREAM),
-                    self.version,
-                    length,
-                    self.ctype,
-                    &self.config,
-                )?;
-                // self.headers_size = (dst.len() - len) as u32;
-            }
-            Message::Chunk(Some(bytes)) => {
-                self.encoder.encode_chunk(bytes.as_ref(), dst)?;
-            }
-            Message::Chunk(None) => {
-                self.encoder.encode_eof(dst)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{cmp, io};
-
-    use actix_codec::{AsyncRead, AsyncWrite};
-    use bytes::{Buf, Bytes, BytesMut};
-    use http::{Method, Version};
-
-    use super::*;
-    use crate::error::ParseError;
-    use crate::h1::Message;
-    use crate::httpmessage::HttpMessage;
-    use crate::request::Request;
-
-    #[test]
-    fn test_http_request_chunked_payload_and_next_message() {
-        let mut codec = Codec::default();
-
-        let mut buf = BytesMut::from(
-            "GET /test HTTP/1.1\r\n\
-             transfer-encoding: chunked\r\n\r\n",
-        );
-        let item = codec.decode(&mut buf).unwrap().unwrap();
-        let req = item.message();
-
-        assert_eq!(req.method(), Method::GET);
-        assert!(req.chunked().unwrap());
-
-        buf.extend(
-            b"4\r\ndata\r\n4\r\nline\r\n0\r\n\r\n\
-               POST /test2 HTTP/1.1\r\n\
-               transfer-encoding: chunked\r\n\r\n"
-                .iter(),
-        );
-
-        let msg = codec.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"data");
-
-        let msg = codec.decode(&mut buf).unwrap().unwrap();
-        assert_eq!(msg.chunk().as_ref(), b"line");
-
-        let msg = codec.decode(&mut buf).unwrap().unwrap();
-        assert!(msg.eof());
-
-        // decode next message
-        let item = codec.decode(&mut buf).unwrap().unwrap();
-        let req = item.message();
-        assert_eq!(*req.method(), Method::POST);
-        assert!(req.chunked().unwrap());
-    }
-}
--- a/actix-http/src/h1/decoder.rs
+++ b/actix-http/src/h1/decoder.rs
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@@ -1,877 +0,0 @@
-use std::collections::VecDeque;
-use std::time::Instant;
-use std::{fmt, io, net};
-
-use actix_codec::{Decoder, Encoder, Framed, FramedParts};
-use actix_server_config::IoStream;
-use actix_service::Service;
-use bitflags::bitflags;
-use bytes::{BufMut, BytesMut};
-use futures::{Async, Future, Poll};
-use log::{error, trace};
-use tokio_timer::Delay;
-
-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
-use crate::cloneable::CloneableService;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
-use crate::error::{ParseError, PayloadError};
-use crate::helpers::DataFactory;
-use crate::httpmessage::HttpMessage;
-use crate::request::Request;
-use crate::response::Response;
-
-use super::codec::Codec;
-use super::payload::{Payload, PayloadSender, PayloadStatus};
-use super::{Message, MessageType};
-
-const LW_BUFFER_SIZE: usize = 4096;
-const HW_BUFFER_SIZE: usize = 32_768;
-const MAX_PIPELINED_MESSAGES: usize = 16;
-
-bitflags! {
-    pub struct Flags: u8 {
-        const STARTED            = 0b0000_0001;
-        const KEEPALIVE          = 0b0000_0010;
-        const POLLED             = 0b0000_0100;
-        const SHUTDOWN           = 0b0000_1000;
-        const READ_DISCONNECT    = 0b0001_0000;
-        const WRITE_DISCONNECT   = 0b0010_0000;
-        const UPGRADE            = 0b0100_0000;
-    }
-}
-
-/// Dispatcher for HTTP/1.1 protocol
-pub struct Dispatcher<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    inner: DispatcherState<T, S, B, X, U>,
-}
-
-enum DispatcherState<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    Normal(InnerDispatcher<T, S, B, X, U>),
-    Upgrade(U::Future),
-    None,
-}
-
-struct InnerDispatcher<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    service: CloneableService<S>,
-    expect: CloneableService<X>,
-    upgrade: Option<CloneableService<U>>,
-    on_connect: Option<Box<dyn DataFactory>>,
-    flags: Flags,
-    peer_addr: Option<net::SocketAddr>,
-    error: Option<DispatchError>,
-
-    state: State<S, B, X>,
-    payload: Option<PayloadSender>,
-    messages: VecDeque<DispatcherMessage>,
-
-    ka_expire: Instant,
-    ka_timer: Option<Delay>,
-
-    io: T,
-    read_buf: BytesMut,
-    write_buf: BytesMut,
-    codec: Codec,
-}
-
-enum DispatcherMessage {
-    Item(Request),
-    Upgrade(Request),
-    Error(Response<()>),
-}
-
-enum State<S, B, X>
-where
-    S: Service<Request = Request>,
-    X: Service<Request = Request, Response = Request>,
-    B: MessageBody,
-{
-    None,
-    ExpectCall(X::Future),
-    ServiceCall(S::Future),
-    SendPayload(ResponseBody<B>),
-}
-
-impl<S, B, X> State<S, B, X>
-where
-    S: Service<Request = Request>,
-    X: Service<Request = Request, Response = Request>,
-    B: MessageBody,
-{
-    fn is_empty(&self) -> bool {
-        if let State::None = self {
-            true
-        } else {
-            false
-        }
-    }
-
-    fn is_call(&self) -> bool {
-        if let State::ServiceCall(_) = self {
-            true
-        } else {
-            false
-        }
-    }
-}
-
-enum PollResponse {
-    Upgrade(Request),
-    DoNothing,
-    DrainWriteBuf,
-}
-
-impl PartialEq for PollResponse {
-    fn eq(&self, other: &PollResponse) -> bool {
-        match self {
-            PollResponse::DrainWriteBuf => match other {
-                PollResponse::DrainWriteBuf => true,
-                _ => false,
-            },
-            PollResponse::DoNothing => match other {
-                PollResponse::DoNothing => true,
-                _ => false,
-            },
-            _ => false,
-        }
-    }
-}
-
-impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    /// Create http/1 dispatcher.
-    pub(crate) fn new(
-        stream: T,
-        config: ServiceConfig,
-        service: CloneableService<S>,
-        expect: CloneableService<X>,
-        upgrade: Option<CloneableService<U>>,
-        on_connect: Option<Box<dyn DataFactory>>,
-    ) -> Self {
-        Dispatcher::with_timeout(
-            stream,
-            Codec::new(config.clone()),
-            config,
-            BytesMut::with_capacity(HW_BUFFER_SIZE),
-            None,
-            service,
-            expect,
-            upgrade,
-            on_connect,
-        )
-    }
-
-    /// Create http/1 dispatcher with slow request timeout.
-    pub(crate) fn with_timeout(
-        io: T,
-        codec: Codec,
-        config: ServiceConfig,
-        read_buf: BytesMut,
-        timeout: Option<Delay>,
-        service: CloneableService<S>,
-        expect: CloneableService<X>,
-        upgrade: Option<CloneableService<U>>,
-        on_connect: Option<Box<dyn DataFactory>>,
-    ) -> Self {
-        let keepalive = config.keep_alive_enabled();
-        let flags = if keepalive {
-            Flags::KEEPALIVE
-        } else {
-            Flags::empty()
-        };
-
-        // keep-alive timer
-        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
-            (delay.deadline(), Some(delay))
-        } else if let Some(delay) = config.keep_alive_timer() {
-            (delay.deadline(), Some(delay))
-        } else {
-            (config.now(), None)
-        };
-
-        Dispatcher {
-            inner: DispatcherState::Normal(InnerDispatcher {
-                write_buf: BytesMut::with_capacity(HW_BUFFER_SIZE),
-                payload: None,
-                state: State::None,
-                error: None,
-                peer_addr: io.peer_addr(),
-                messages: VecDeque::new(),
-                io,
-                codec,
-                read_buf,
-                service,
-                expect,
-                upgrade,
-                on_connect,
-                flags,
-                ka_expire,
-                ka_timer,
-            }),
-        }
-    }
-}
-
-impl<T, S, B, X, U> InnerDispatcher<T, S, B, X, U>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn can_read(&self) -> bool {
-        if self
-            .flags
-            .intersects(Flags::READ_DISCONNECT | Flags::UPGRADE)
-        {
-            false
-        } else if let Some(ref info) = self.payload {
-            info.need_read() == PayloadStatus::Read
-        } else {
-            true
-        }
-    }
-
-    // if checked is set to true, delay disconnect until all tasks have finished.
-    fn client_disconnected(&mut self) {
-        self.flags
-            .insert(Flags::READ_DISCONNECT | Flags::WRITE_DISCONNECT);
-        if let Some(mut payload) = self.payload.take() {
-            payload.set_error(PayloadError::Incomplete(None));
-        }
-    }
-
-    /// Flush stream
-    ///
-    /// true - got whouldblock
-    /// false - didnt get whouldblock
-    fn poll_flush(&mut self) -> Result<bool, DispatchError> {
-        if self.write_buf.is_empty() {
-            return Ok(false);
-        }
-
-        let len = self.write_buf.len();
-        let mut written = 0;
-        while written < len {
-            match self.io.write(&self.write_buf[written..]) {
-                Ok(0) => {
-                    return Err(DispatchError::Io(io::Error::new(
-                        io::ErrorKind::WriteZero,
-                        "",
-                    )));
-                }
-                Ok(n) => {
-                    written += n;
-                }
-                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-                    if written > 0 {
-                        let _ = self.write_buf.split_to(written);
-                    }
-                    return Ok(true);
-                }
-                Err(err) => return Err(DispatchError::Io(err)),
-            }
-        }
-        if written > 0 {
-            if written == self.write_buf.len() {
-                unsafe { self.write_buf.set_len(0) }
-            } else {
-                let _ = self.write_buf.split_to(written);
-            }
-        }
-        Ok(false)
-    }
-
-    fn send_response(
-        &mut self,
-        message: Response<()>,
-        body: ResponseBody<B>,
-    ) -> Result<State<S, B, X>, DispatchError> {
-        self.codec
-            .encode(Message::Item((message, body.size())), &mut self.write_buf)
-            .map_err(|err| {
-                if let Some(mut payload) = self.payload.take() {
-                    payload.set_error(PayloadError::Incomplete(None));
-                }
-                DispatchError::Io(err)
-            })?;
-
-        self.flags.set(Flags::KEEPALIVE, self.codec.keepalive());
-        match body.size() {
-            BodySize::None | BodySize::Empty => Ok(State::None),
-            _ => Ok(State::SendPayload(body)),
-        }
-    }
-
-    fn send_continue(&mut self) {
-        self.write_buf
-            .extend_from_slice(b"HTTP/1.1 100 Continue\r\n\r\n");
-    }
-
-    fn poll_response(&mut self) -> Result<PollResponse, DispatchError> {
-        loop {
-            let state = match self.state {
-                State::None => match self.messages.pop_front() {
-                    Some(DispatcherMessage::Item(req)) => {
-                        Some(self.handle_request(req)?)
-                    }
-                    Some(DispatcherMessage::Error(res)) => {
-                        Some(self.send_response(res, ResponseBody::Other(Body::Empty))?)
-                    }
-                    Some(DispatcherMessage::Upgrade(req)) => {
-                        return Ok(PollResponse::Upgrade(req));
-                    }
-                    None => None,
-                },
-                State::ExpectCall(ref mut fut) => match fut.poll() {
-                    Ok(Async::Ready(req)) => {
-                        self.send_continue();
-                        self.state = State::ServiceCall(self.service.call(req));
-                        continue;
-                    }
-                    Ok(Async::NotReady) => None,
-                    Err(e) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-                        Some(self.send_response(res, body.into_body())?)
-                    }
-                },
-                State::ServiceCall(ref mut fut) => match fut.poll() {
-                    Ok(Async::Ready(res)) => {
-                        let (res, body) = res.into().replace_body(());
-                        self.state = self.send_response(res, body)?;
-                        continue;
-                    }
-                    Ok(Async::NotReady) => None,
-                    Err(e) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-                        Some(self.send_response(res, body.into_body())?)
-                    }
-                },
-                State::SendPayload(ref mut stream) => {
-                    loop {
-                        if self.write_buf.len() < HW_BUFFER_SIZE {
-                            match stream
-                                .poll_next()
-                                .map_err(|_| DispatchError::Unknown)?
-                            {
-                                Async::Ready(Some(item)) => {
-                                    self.codec.encode(
-                                        Message::Chunk(Some(item)),
-                                        &mut self.write_buf,
-                                    )?;
-                                    continue;
-                                }
-                                Async::Ready(None) => {
-                                    self.codec.encode(
-                                        Message::Chunk(None),
-                                        &mut self.write_buf,
-                                    )?;
-                                    self.state = State::None;
-                                }
-                                Async::NotReady => return Ok(PollResponse::DoNothing),
-                            }
-                        } else {
-                            return Ok(PollResponse::DrainWriteBuf);
-                        }
-                        break;
-                    }
-                    continue;
-                }
-            };
-
-            // set new state
-            if let Some(state) = state {
-                self.state = state;
-                if !self.state.is_empty() {
-                    continue;
-                }
-            } else {
-                // if read-backpressure is enabled and we consumed some data.
-                // we may read more data and retry
-                if self.state.is_call() {
-                    if self.poll_request()? {
-                        continue;
-                    }
-                } else if !self.messages.is_empty() {
-                    continue;
-                }
-            }
-            break;
-        }
-
-        Ok(PollResponse::DoNothing)
-    }
-
-    fn handle_request(&mut self, req: Request) -> Result<State<S, B, X>, DispatchError> {
-        // Handle `EXPECT: 100-Continue` header
-        let req = if req.head().expect() {
-            let mut task = self.expect.call(req);
-            match task.poll() {
-                Ok(Async::Ready(req)) => {
-                    self.send_continue();
-                    req
-                }
-                Ok(Async::NotReady) => return Ok(State::ExpectCall(task)),
-                Err(e) => {
-                    let e = e.into();
-                    let res: Response = e.into();
-                    let (res, body) = res.replace_body(());
-                    return self.send_response(res, body.into_body());
-                }
-            }
-        } else {
-            req
-        };
-
-        // Call service
-        let mut task = self.service.call(req);
-        match task.poll() {
-            Ok(Async::Ready(res)) => {
-                let (res, body) = res.into().replace_body(());
-                self.send_response(res, body)
-            }
-            Ok(Async::NotReady) => Ok(State::ServiceCall(task)),
-            Err(e) => {
-                let res: Response = e.into().into();
-                let (res, body) = res.replace_body(());
-                self.send_response(res, body.into_body())
-            }
-        }
-    }
-
-    /// Process one incoming requests
-    pub(self) fn poll_request(&mut self) -> Result<bool, DispatchError> {
-        // limit a mount of non processed requests
-        if self.messages.len() >= MAX_PIPELINED_MESSAGES || !self.can_read() {
-            return Ok(false);
-        }
-
-        let mut updated = false;
-        loop {
-            match self.codec.decode(&mut self.read_buf) {
-                Ok(Some(msg)) => {
-                    updated = true;
-                    self.flags.insert(Flags::STARTED);
-
-                    match msg {
-                        Message::Item(mut req) => {
-                            let pl = self.codec.message_type();
-                            req.head_mut().peer_addr = self.peer_addr;
-
-                            // set on_connect data
-                            if let Some(ref on_connect) = self.on_connect {
-                                on_connect.set(&mut req.extensions_mut());
-                            }
-
-                            if pl == MessageType::Stream && self.upgrade.is_some() {
-                                self.messages.push_back(DispatcherMessage::Upgrade(req));
-                                break;
-                            }
-                            if pl == MessageType::Payload || pl == MessageType::Stream {
-                                let (ps, pl) = Payload::create(false);
-                                let (req1, _) =
-                                    req.replace_payload(crate::Payload::H1(pl));
-                                req = req1;
-                                self.payload = Some(ps);
-                            }
-
-                            // handle request early
-                            if self.state.is_empty() {
-                                self.state = self.handle_request(req)?;
-                            } else {
-                                self.messages.push_back(DispatcherMessage::Item(req));
-                            }
-                        }
-                        Message::Chunk(Some(chunk)) => {
-                            if let Some(ref mut payload) = self.payload {
-                                payload.feed_data(chunk);
-                            } else {
-                                error!(
-                                    "Internal server error: unexpected payload chunk"
-                                );
-                                self.flags.insert(Flags::READ_DISCONNECT);
-                                self.messages.push_back(DispatcherMessage::Error(
-                                    Response::InternalServerError().finish().drop_body(),
-                                ));
-                                self.error = Some(DispatchError::InternalError);
-                                break;
-                            }
-                        }
-                        Message::Chunk(None) => {
-                            if let Some(mut payload) = self.payload.take() {
-                                payload.feed_eof();
-                            } else {
-                                error!("Internal server error: unexpected eof");
-                                self.flags.insert(Flags::READ_DISCONNECT);
-                                self.messages.push_back(DispatcherMessage::Error(
-                                    Response::InternalServerError().finish().drop_body(),
-                                ));
-                                self.error = Some(DispatchError::InternalError);
-                                break;
-                            }
-                        }
-                    }
-                }
-                Ok(None) => break,
-                Err(ParseError::Io(e)) => {
-                    self.client_disconnected();
-                    self.error = Some(DispatchError::Io(e));
-                    break;
-                }
-                Err(e) => {
-                    if let Some(mut payload) = self.payload.take() {
-                        payload.set_error(PayloadError::EncodingCorrupted);
-                    }
-
-                    // Malformed requests should be responded with 400
-                    self.messages.push_back(DispatcherMessage::Error(
-                        Response::BadRequest().finish().drop_body(),
-                    ));
-                    self.flags.insert(Flags::READ_DISCONNECT);
-                    self.error = Some(e.into());
-                    break;
-                }
-            }
-        }
-
-        if updated && self.ka_timer.is_some() {
-            if let Some(expire) = self.codec.config().keep_alive_expire() {
-                self.ka_expire = expire;
-            }
-        }
-        Ok(updated)
-    }
-
-    /// keep-alive timer
-    fn poll_keepalive(&mut self) -> Result<(), DispatchError> {
-        if self.ka_timer.is_none() {
-            // shutdown timeout
-            if self.flags.contains(Flags::SHUTDOWN) {
-                if let Some(interval) = self.codec.config().client_disconnect_timer() {
-                    self.ka_timer = Some(Delay::new(interval));
-                } else {
-                    self.flags.insert(Flags::READ_DISCONNECT);
-                    if let Some(mut payload) = self.payload.take() {
-                        payload.set_error(PayloadError::Incomplete(None));
-                    }
-                    return Ok(());
-                }
-            } else {
-                return Ok(());
-            }
-        }
-
-        match self.ka_timer.as_mut().unwrap().poll().map_err(|e| {
-            error!("Timer error {:?}", e);
-            DispatchError::Unknown
-        })? {
-            Async::Ready(_) => {
-                // if we get timeout during shutdown, drop connection
-                if self.flags.contains(Flags::SHUTDOWN) {
-                    return Err(DispatchError::DisconnectTimeout);
-                } else if self.ka_timer.as_mut().unwrap().deadline() >= self.ka_expire {
-                    // check for any outstanding tasks
-                    if self.state.is_empty() && self.write_buf.is_empty() {
-                        if self.flags.contains(Flags::STARTED) {
-                            trace!("Keep-alive timeout, close connection");
-                            self.flags.insert(Flags::SHUTDOWN);
-
-                            // start shutdown timer
-                            if let Some(deadline) =
-                                self.codec.config().client_disconnect_timer()
-                            {
-                                if let Some(timer) = self.ka_timer.as_mut() {
-                                    timer.reset(deadline);
-                                    let _ = timer.poll();
-                                }
-                            } else {
-                                // no shutdown timeout, drop socket
-                                self.flags.insert(Flags::WRITE_DISCONNECT);
-                                return Ok(());
-                            }
-                        } else {
-                            // timeout on first request (slow request) return 408
-                            if !self.flags.contains(Flags::STARTED) {
-                                trace!("Slow request timeout");
-                                let _ = self.send_response(
-                                    Response::RequestTimeout().finish().drop_body(),
-                                    ResponseBody::Other(Body::Empty),
-                                );
-                            } else {
-                                trace!("Keep-alive connection timeout");
-                            }
-                            self.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
-                            self.state = State::None;
-                        }
-                    } else if let Some(deadline) =
-                        self.codec.config().keep_alive_expire()
-                    {
-                        if let Some(timer) = self.ka_timer.as_mut() {
-                            timer.reset(deadline);
-                            let _ = timer.poll();
-                        }
-                    }
-                } else if let Some(timer) = self.ka_timer.as_mut() {
-                    timer.reset(self.ka_expire);
-                    let _ = timer.poll();
-                }
-            }
-            Async::NotReady => (),
-        }
-
-        Ok(())
-    }
-}
-
-impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    type Item = ();
-    type Error = DispatchError;
-
-    #[inline]
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.inner {
-            DispatcherState::Normal(ref mut inner) => {
-                inner.poll_keepalive()?;
-
-                if inner.flags.contains(Flags::SHUTDOWN) {
-                    if inner.flags.contains(Flags::WRITE_DISCONNECT) {
-                        Ok(Async::Ready(()))
-                    } else {
-                        // flush buffer
-                        inner.poll_flush()?;
-                        if !inner.write_buf.is_empty() {
-                            Ok(Async::NotReady)
-                        } else {
-                            match inner.io.shutdown()? {
-                                Async::Ready(_) => Ok(Async::Ready(())),
-                                Async::NotReady => Ok(Async::NotReady),
-                            }
-                        }
-                    }
-                } else {
-                    // read socket into a buf
-                    let should_disconnect =
-                        if !inner.flags.contains(Flags::READ_DISCONNECT) {
-                            read_available(&mut inner.io, &mut inner.read_buf)?
-                        } else {
-                            None
-                        };
-
-                    inner.poll_request()?;
-                    if let Some(true) = should_disconnect {
-                        inner.flags.insert(Flags::READ_DISCONNECT);
-                        if let Some(mut payload) = inner.payload.take() {
-                            payload.feed_eof();
-                        }
-                    };
-
-                    loop {
-                        if inner.write_buf.remaining_mut() < LW_BUFFER_SIZE {
-                            inner.write_buf.reserve(HW_BUFFER_SIZE);
-                        }
-                        let result = inner.poll_response()?;
-                        let drain = result == PollResponse::DrainWriteBuf;
-
-                        // switch to upgrade handler
-                        if let PollResponse::Upgrade(req) = result {
-                            if let DispatcherState::Normal(inner) =
-                                std::mem::replace(&mut self.inner, DispatcherState::None)
-                            {
-                                let mut parts = FramedParts::with_read_buf(
-                                    inner.io,
-                                    inner.codec,
-                                    inner.read_buf,
-                                );
-                                parts.write_buf = inner.write_buf;
-                                let framed = Framed::from_parts(parts);
-                                self.inner = DispatcherState::Upgrade(
-                                    inner.upgrade.unwrap().call((req, framed)),
-                                );
-                                return self.poll();
-                            } else {
-                                panic!()
-                            }
-                        }
-
-                        // we didnt get WouldBlock from write operation,
-                        // so data get written to kernel completely (OSX)
-                        // and we have to write again otherwise response can get stuck
-                        if inner.poll_flush()? || !drain {
-                            break;
-                        }
-                    }
-
-                    // client is gone
-                    if inner.flags.contains(Flags::WRITE_DISCONNECT) {
-                        return Ok(Async::Ready(()));
-                    }
-
-                    let is_empty = inner.state.is_empty();
-
-                    // read half is closed and we do not processing any responses
-                    if inner.flags.contains(Flags::READ_DISCONNECT) && is_empty {
-                        inner.flags.insert(Flags::SHUTDOWN);
-                    }
-
-                    // keep-alive and stream errors
-                    if is_empty && inner.write_buf.is_empty() {
-                        if let Some(err) = inner.error.take() {
-                            Err(err)
-                        }
-                        // disconnect if keep-alive is not enabled
-                        else if inner.flags.contains(Flags::STARTED)
-                            && !inner.flags.intersects(Flags::KEEPALIVE)
-                        {
-                            inner.flags.insert(Flags::SHUTDOWN);
-                            self.poll()
-                        }
-                        // disconnect if shutdown
-                        else if inner.flags.contains(Flags::SHUTDOWN) {
-                            self.poll()
-                        } else {
-                            Ok(Async::NotReady)
-                        }
-                    } else {
-                        Ok(Async::NotReady)
-                    }
-                }
-            }
-            DispatcherState::Upgrade(ref mut fut) => fut.poll().map_err(|e| {
-                error!("Upgrade handler error: {}", e);
-                DispatchError::Upgrade
-            }),
-            DispatcherState::None => panic!(),
-        }
-    }
-}
-
-fn read_available<T>(io: &mut T, buf: &mut BytesMut) -> Result<Option<bool>, io::Error>
-where
-    T: io::Read,
-{
-    let mut read_some = false;
-    loop {
-        if buf.remaining_mut() < LW_BUFFER_SIZE {
-            buf.reserve(HW_BUFFER_SIZE);
-        }
-
-        let read = unsafe { io.read(buf.bytes_mut()) };
-        match read {
-            Ok(n) => {
-                if n == 0 {
-                    return Ok(Some(true));
-                } else {
-                    read_some = true;
-                    unsafe {
-                        buf.advance_mut(n);
-                    }
-                }
-            }
-            Err(e) => {
-                return if e.kind() == io::ErrorKind::WouldBlock {
-                    if read_some {
-                        Ok(Some(false))
-                    } else {
-                        Ok(None)
-                    }
-                } else if e.kind() == io::ErrorKind::ConnectionReset && read_some {
-                    Ok(Some(true))
-                } else {
-                    Err(e)
-                };
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use actix_service::IntoService;
-    use futures::future::{lazy, ok};
-
-    use super::*;
-    use crate::error::Error;
-    use crate::h1::{ExpectHandler, UpgradeHandler};
-    use crate::test::TestBuffer;
-
-    #[test]
-    fn test_req_parse_err() {
-        let mut sys = actix_rt::System::new("test");
-        let _ = sys.block_on(lazy(|| {
-            let buf = TestBuffer::new("GET /test HTTP/1\r\n\r\n");
-
-            let mut h1 = Dispatcher::<_, _, _, _, UpgradeHandler<TestBuffer>>::new(
-                buf,
-                ServiceConfig::default(),
-                CloneableService::new(
-                    (|_| ok::<_, Error>(Response::Ok().finish())).into_service(),
-                ),
-                CloneableService::new(ExpectHandler),
-                None,
-                None,
-            );
-            assert!(h1.poll().is_err());
-
-            if let DispatcherState::Normal(ref inner) = h1.inner {
-                assert!(inner.flags.contains(Flags::READ_DISCONNECT));
-                assert_eq!(&inner.io.write_buf[..26], b"HTTP/1.1 400 Bad Request\r\n");
-            }
-            ok::<_, ()>(())
-        }));
-    }
-}
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@@ -1,636 +0,0 @@
-#![allow(unused_imports, unused_variables, dead_code)]
-use std::fmt::Write as FmtWrite;
-use std::io::Write;
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::str::FromStr;
-use std::{cmp, fmt, io, mem};
-
-use bytes::{BufMut, Bytes, BytesMut};
-
-use crate::body::BodySize;
-use crate::config::ServiceConfig;
-use crate::header::{map, ContentEncoding};
-use crate::helpers;
-use crate::http::header::{
-    HeaderValue, ACCEPT_ENCODING, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
-};
-use crate::http::{HeaderMap, Method, StatusCode, Version};
-use crate::message::{ConnectionType, Head, RequestHead, RequestHeadType, ResponseHead};
-use crate::request::Request;
-use crate::response::Response;
-
-const AVERAGE_HEADER_SIZE: usize = 30;
-
-#[derive(Debug)]
-pub(crate) struct MessageEncoder<T: MessageType> {
-    pub length: BodySize,
-    pub te: TransferEncoding,
-    _t: PhantomData<T>,
-}
-
-impl<T: MessageType> Default for MessageEncoder<T> {
-    fn default() -> Self {
-        MessageEncoder {
-            length: BodySize::None,
-            te: TransferEncoding::empty(),
-            _t: PhantomData,
-        }
-    }
-}
-
-pub(crate) trait MessageType: Sized {
-    fn status(&self) -> Option<StatusCode>;
-
-    fn headers(&self) -> &HeaderMap;
-
-    fn extra_headers(&self) -> Option<&HeaderMap>;
-
-    fn camel_case(&self) -> bool {
-        false
-    }
-
-    fn chunked(&self) -> bool;
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()>;
-
-    fn encode_headers(
-        &mut self,
-        dst: &mut BytesMut,
-        version: Version,
-        mut length: BodySize,
-        ctype: ConnectionType,
-        config: &ServiceConfig,
-    ) -> io::Result<()> {
-        let chunked = self.chunked();
-        let mut skip_len = length != BodySize::Stream;
-        let camel_case = self.camel_case();
-
-        // Content length
-        if let Some(status) = self.status() {
-            match status {
-                StatusCode::NO_CONTENT
-                | StatusCode::CONTINUE
-                | StatusCode::PROCESSING => length = BodySize::None,
-                StatusCode::SWITCHING_PROTOCOLS => {
-                    skip_len = true;
-                    length = BodySize::Stream;
-                }
-                _ => (),
-            }
-        }
-        match length {
-            BodySize::Stream => {
-                if chunked {
-                    if camel_case {
-                        dst.put_slice(b"\r\nTransfer-Encoding: chunked\r\n")
-                    } else {
-                        dst.put_slice(b"\r\ntransfer-encoding: chunked\r\n")
-                    }
-                } else {
-                    skip_len = false;
-                    dst.put_slice(b"\r\n");
-                }
-            }
-            BodySize::Empty => {
-                if camel_case {
-                    dst.put_slice(b"\r\nContent-Length: 0\r\n");
-                } else {
-                    dst.put_slice(b"\r\ncontent-length: 0\r\n");
-                }
-            }
-            BodySize::Sized(len) => helpers::write_content_length(len, dst),
-            BodySize::Sized64(len) => {
-                if camel_case {
-                    dst.put_slice(b"\r\nContent-Length: ");
-                } else {
-                    dst.put_slice(b"\r\ncontent-length: ");
-                }
-                write!(dst.writer(), "{}\r\n", len)?;
-            }
-            BodySize::None => dst.put_slice(b"\r\n"),
-        }
-
-        // Connection
-        match ctype {
-            ConnectionType::Upgrade => dst.put_slice(b"connection: upgrade\r\n"),
-            ConnectionType::KeepAlive if version < Version::HTTP_11 => {
-                if camel_case {
-                    dst.put_slice(b"Connection: keep-alive\r\n")
-                } else {
-                    dst.put_slice(b"connection: keep-alive\r\n")
-                }
-            }
-            ConnectionType::Close if version >= Version::HTTP_11 => {
-                if camel_case {
-                    dst.put_slice(b"Connection: close\r\n")
-                } else {
-                    dst.put_slice(b"connection: close\r\n")
-                }
-            }
-            _ => (),
-        }
-
-        // merging headers from head and extra headers. HeaderMap::new() does not allocate.
-        let empty_headers = HeaderMap::new();
-        let extra_headers = self.extra_headers().unwrap_or(&empty_headers);
-        let headers = self
-            .headers()
-            .inner
-            .iter()
-            .filter(|(name, _)| !extra_headers.contains_key(*name))
-            .chain(extra_headers.inner.iter());
-
-        // write headers
-        let mut pos = 0;
-        let mut has_date = false;
-        let mut remaining = dst.remaining_mut();
-        let mut buf = unsafe { &mut *(dst.bytes_mut() as *mut [u8]) };
-        for (key, value) in headers {
-            match *key {
-                CONNECTION => continue,
-                TRANSFER_ENCODING | CONTENT_LENGTH if skip_len => continue,
-                DATE => {
-                    has_date = true;
-                }
-                _ => (),
-            }
-            let k = key.as_str().as_bytes();
-            match value {
-                map::Value::One(ref val) => {
-                    let v = val.as_ref();
-                    let len = k.len() + v.len() + 4;
-                    if len > remaining {
-                        unsafe {
-                            dst.advance_mut(pos);
-                        }
-                        pos = 0;
-                        dst.reserve(len * 2);
-                        remaining = dst.remaining_mut();
-                        unsafe {
-                            buf = &mut *(dst.bytes_mut() as *mut _);
-                        }
-                    }
-                    // use upper Camel-Case
-                    if camel_case {
-                        write_camel_case(k, &mut buf[pos..pos + k.len()]);
-                    } else {
-                        buf[pos..pos + k.len()].copy_from_slice(k);
-                    }
-                    pos += k.len();
-                    buf[pos..pos + 2].copy_from_slice(b": ");
-                    pos += 2;
-                    buf[pos..pos + v.len()].copy_from_slice(v);
-                    pos += v.len();
-                    buf[pos..pos + 2].copy_from_slice(b"\r\n");
-                    pos += 2;
-                    remaining -= len;
-                }
-                map::Value::Multi(ref vec) => {
-                    for val in vec {
-                        let v = val.as_ref();
-                        let len = k.len() + v.len() + 4;
-                        if len > remaining {
-                            unsafe {
-                                dst.advance_mut(pos);
-                            }
-                            pos = 0;
-                            dst.reserve(len * 2);
-                            remaining = dst.remaining_mut();
-                            unsafe {
-                                buf = &mut *(dst.bytes_mut() as *mut _);
-                            }
-                        }
-                        // use upper Camel-Case
-                        if camel_case {
-                            write_camel_case(k, &mut buf[pos..pos + k.len()]);
-                        } else {
-                            buf[pos..pos + k.len()].copy_from_slice(k);
-                        }
-                        pos += k.len();
-                        buf[pos..pos + 2].copy_from_slice(b": ");
-                        pos += 2;
-                        buf[pos..pos + v.len()].copy_from_slice(v);
-                        pos += v.len();
-                        buf[pos..pos + 2].copy_from_slice(b"\r\n");
-                        pos += 2;
-                        remaining -= len;
-                    }
-                }
-            }
-        }
-        unsafe {
-            dst.advance_mut(pos);
-        }
-
-        // optimized date header, set_date writes \r\n
-        if !has_date {
-            config.set_date(dst);
-        } else {
-            // msg eof
-            dst.extend_from_slice(b"\r\n");
-        }
-
-        Ok(())
-    }
-}
-
-impl MessageType for Response<()> {
-    fn status(&self) -> Option<StatusCode> {
-        Some(self.head().status)
-    }
-
-    fn chunked(&self) -> bool {
-        self.head().chunked()
-    }
-
-    fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    fn extra_headers(&self) -> Option<&HeaderMap> {
-        None
-    }
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
-        let head = self.head();
-        let reason = head.reason().as_bytes();
-        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE + reason.len());
-
-        // status line
-        helpers::write_status_line(head.version, head.status.as_u16(), dst);
-        dst.put_slice(reason);
-        Ok(())
-    }
-}
-
-impl MessageType for RequestHeadType {
-    fn status(&self) -> Option<StatusCode> {
-        None
-    }
-
-    fn chunked(&self) -> bool {
-        self.as_ref().chunked()
-    }
-
-    fn camel_case(&self) -> bool {
-        self.as_ref().camel_case_headers()
-    }
-
-    fn headers(&self) -> &HeaderMap {
-        self.as_ref().headers()
-    }
-
-    fn extra_headers(&self) -> Option<&HeaderMap> {
-        self.extra_headers()
-    }
-
-    fn encode_status(&mut self, dst: &mut BytesMut) -> io::Result<()> {
-        let head = self.as_ref();
-        dst.reserve(256 + head.headers.len() * AVERAGE_HEADER_SIZE);
-        write!(
-            Writer(dst),
-            "{} {} {}",
-            head.method,
-            head.uri.path_and_query().map(|u| u.as_str()).unwrap_or("/"),
-            match head.version {
-                Version::HTTP_09 => "HTTP/0.9",
-                Version::HTTP_10 => "HTTP/1.0",
-                Version::HTTP_11 => "HTTP/1.1",
-                Version::HTTP_2 => "HTTP/2.0",
-            }
-        )
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
-    }
-}
-
-impl<T: MessageType> MessageEncoder<T> {
-    /// Encode message
-    pub fn encode_chunk(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Result<bool> {
-        self.te.encode(msg, buf)
-    }
-
-    /// Encode eof
-    pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
-        self.te.encode_eof(buf)
-    }
-
-    pub fn encode(
-        &mut self,
-        dst: &mut BytesMut,
-        message: &mut T,
-        head: bool,
-        stream: bool,
-        version: Version,
-        length: BodySize,
-        ctype: ConnectionType,
-        config: &ServiceConfig,
-    ) -> io::Result<()> {
-        // transfer encoding
-        if !head {
-            self.te = match length {
-                BodySize::Empty => TransferEncoding::empty(),
-                BodySize::Sized(len) => TransferEncoding::length(len as u64),
-                BodySize::Sized64(len) => TransferEncoding::length(len),
-                BodySize::Stream => {
-                    if message.chunked() && !stream {
-                        TransferEncoding::chunked()
-                    } else {
-                        TransferEncoding::eof()
-                    }
-                }
-                BodySize::None => TransferEncoding::empty(),
-            };
-        } else {
-            self.te = TransferEncoding::empty();
-        }
-
-        message.encode_status(dst)?;
-        message.encode_headers(dst, version, length, ctype, config)
-    }
-}
-
-/// Encoders to handle different Transfer-Encodings.
-#[derive(Debug)]
-pub(crate) struct TransferEncoding {
-    kind: TransferEncodingKind,
-}
-
-#[derive(Debug, PartialEq, Clone)]
-enum TransferEncodingKind {
-    /// An Encoder for when Transfer-Encoding includes `chunked`.
-    Chunked(bool),
-    /// An Encoder for when Content-Length is set.
-    ///
-    /// Enforces that the body is not longer than the Content-Length header.
-    Length(u64),
-    /// An Encoder for when Content-Length is not known.
-    ///
-    /// Application decides when to stop writing.
-    Eof,
-}
-
-impl TransferEncoding {
-    #[inline]
-    pub fn empty() -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Length(0),
-        }
-    }
-
-    #[inline]
-    pub fn eof() -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Eof,
-        }
-    }
-
-    #[inline]
-    pub fn chunked() -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Chunked(false),
-        }
-    }
-
-    #[inline]
-    pub fn length(len: u64) -> TransferEncoding {
-        TransferEncoding {
-            kind: TransferEncodingKind::Length(len),
-        }
-    }
-
-    /// Encode message. Return `EOF` state of encoder
-    #[inline]
-    pub fn encode(&mut self, msg: &[u8], buf: &mut BytesMut) -> io::Result<bool> {
-        match self.kind {
-            TransferEncodingKind::Eof => {
-                let eof = msg.is_empty();
-                buf.extend_from_slice(msg);
-                Ok(eof)
-            }
-            TransferEncodingKind::Chunked(ref mut eof) => {
-                if *eof {
-                    return Ok(true);
-                }
-
-                if msg.is_empty() {
-                    *eof = true;
-                    buf.extend_from_slice(b"0\r\n\r\n");
-                } else {
-                    writeln!(Writer(buf), "{:X}\r", msg.len())
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-
-                    buf.reserve(msg.len() + 2);
-                    buf.extend_from_slice(msg);
-                    buf.extend_from_slice(b"\r\n");
-                }
-                Ok(*eof)
-            }
-            TransferEncodingKind::Length(ref mut remaining) => {
-                if *remaining > 0 {
-                    if msg.is_empty() {
-                        return Ok(*remaining == 0);
-                    }
-                    let len = cmp::min(*remaining, msg.len() as u64);
-
-                    buf.extend_from_slice(&msg[..len as usize]);
-
-                    *remaining -= len as u64;
-                    Ok(*remaining == 0)
-                } else {
-                    Ok(true)
-                }
-            }
-        }
-    }
-
-    /// Encode eof. Return `EOF` state of encoder
-    #[inline]
-    pub fn encode_eof(&mut self, buf: &mut BytesMut) -> io::Result<()> {
-        match self.kind {
-            TransferEncodingKind::Eof => Ok(()),
-            TransferEncodingKind::Length(rem) => {
-                if rem != 0 {
-                    Err(io::Error::new(io::ErrorKind::UnexpectedEof, ""))
-                } else {
-                    Ok(())
-                }
-            }
-            TransferEncodingKind::Chunked(ref mut eof) => {
-                if !*eof {
-                    *eof = true;
-                    buf.extend_from_slice(b"0\r\n\r\n");
-                }
-                Ok(())
-            }
-        }
-    }
-}
-
-struct Writer<'a>(pub &'a mut BytesMut);
-
-impl<'a> io::Write for Writer<'a> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.0.extend_from_slice(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
-    let mut index = 0;
-    let key = value;
-    let mut key_iter = key.iter();
-
-    if let Some(c) = key_iter.next() {
-        if *c >= b'a' && *c <= b'z' {
-            buffer[index] = *c ^ b' ';
-            index += 1;
-        }
-    } else {
-        return;
-    }
-
-    while let Some(c) = key_iter.next() {
-        buffer[index] = *c;
-        index += 1;
-        if *c == b'-' {
-            if let Some(c) = key_iter.next() {
-                if *c >= b'a' && *c <= b'z' {
-                    buffer[index] = *c ^ b' ';
-                    index += 1;
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use bytes::Bytes;
-    //use std::rc::Rc;
-
-    use super::*;
-    use crate::http::header::{HeaderValue, CONTENT_TYPE};
-    use http::header::AUTHORIZATION;
-
-    #[test]
-    fn test_chunked_te() {
-        let mut bytes = BytesMut::new();
-        let mut enc = TransferEncoding::chunked();
-        {
-            assert!(!enc.encode(b"test", &mut bytes).ok().unwrap());
-            assert!(enc.encode(b"", &mut bytes).ok().unwrap());
-        }
-        assert_eq!(
-            bytes.take().freeze(),
-            Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
-        );
-    }
-
-    #[test]
-    fn test_camel_case() {
-        let mut bytes = BytesMut::with_capacity(2048);
-        let mut head = RequestHead::default();
-        head.set_camel_case_headers(true);
-        head.headers.insert(DATE, HeaderValue::from_static("date"));
-        head.headers
-            .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
-
-        let mut head = RequestHeadType::Owned(head);
-
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Empty,
-            ConnectionType::Close,
-            &ServiceConfig::default(),
-        );
-        let data = String::from_utf8(Vec::from(bytes.take().freeze().as_ref())).unwrap();
-        assert!(data.contains("Content-Length: 0\r\n"));
-        assert!(data.contains("Connection: close\r\n"));
-        assert!(data.contains("Content-Type: plain/text\r\n"));
-        assert!(data.contains("Date: date\r\n"));
-
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Stream,
-            ConnectionType::KeepAlive,
-            &ServiceConfig::default(),
-        );
-        let data = String::from_utf8(Vec::from(bytes.take().freeze().as_ref())).unwrap();
-        assert!(data.contains("Transfer-Encoding: chunked\r\n"));
-        assert!(data.contains("Content-Type: plain/text\r\n"));
-        assert!(data.contains("Date: date\r\n"));
-
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Sized64(100),
-            ConnectionType::KeepAlive,
-            &ServiceConfig::default(),
-        );
-        let data = String::from_utf8(Vec::from(bytes.take().freeze().as_ref())).unwrap();
-        assert!(data.contains("Content-Length: 100\r\n"));
-        assert!(data.contains("Content-Type: plain/text\r\n"));
-        assert!(data.contains("Date: date\r\n"));
-
-        let mut head = RequestHead::default();
-        head.set_camel_case_headers(false);
-        head.headers.insert(DATE, HeaderValue::from_static("date"));
-        head.headers
-            .insert(CONTENT_TYPE, HeaderValue::from_static("plain/text"));
-        head.headers
-            .append(CONTENT_TYPE, HeaderValue::from_static("xml"));
-
-        let mut head = RequestHeadType::Owned(head);
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Stream,
-            ConnectionType::KeepAlive,
-            &ServiceConfig::default(),
-        );
-        let data = String::from_utf8(Vec::from(bytes.take().freeze().as_ref())).unwrap();
-        assert!(data.contains("transfer-encoding: chunked\r\n"));
-        assert!(data.contains("content-type: xml\r\n"));
-        assert!(data.contains("content-type: plain/text\r\n"));
-        assert!(data.contains("date: date\r\n"));
-    }
-
-    #[test]
-    fn test_extra_headers() {
-        let mut bytes = BytesMut::with_capacity(2048);
-
-        let mut head = RequestHead::default();
-        head.headers.insert(
-            AUTHORIZATION,
-            HeaderValue::from_static("some authorization"),
-        );
-
-        let mut extra_headers = HeaderMap::new();
-        extra_headers.insert(
-            AUTHORIZATION,
-            HeaderValue::from_static("another authorization"),
-        );
-        extra_headers.insert(DATE, HeaderValue::from_static("date"));
-
-        let mut head = RequestHeadType::Rc(Rc::new(head), Some(extra_headers));
-
-        let _ = head.encode_headers(
-            &mut bytes,
-            Version::HTTP_11,
-            BodySize::Empty,
-            ConnectionType::Close,
-            &ServiceConfig::default(),
-        );
-        let data = String::from_utf8(Vec::from(bytes.take().freeze().as_ref())).unwrap();
-        assert!(data.contains("content-length: 0\r\n"));
-        assert!(data.contains("connection: close\r\n"));
-        assert!(data.contains("authorization: another authorization\r\n"));
-        assert!(data.contains("date: date\r\n"));
-    }
-}
--- a/actix-http/src/h1/expect.rs
+++ b/actix-http/src/h1/expect.rs
@@ -1,38 +0,0 @@
-use actix_server_config::ServerConfig;
-use actix_service::{NewService, Service};
-use futures::future::{ok, FutureResult};
-use futures::{Async, Poll};
-
-use crate::error::Error;
-use crate::request::Request;
-
-pub struct ExpectHandler;
-
-impl NewService for ExpectHandler {
-    type Config = ServerConfig;
-    type Request = Request;
-    type Response = Request;
-    type Error = Error;
-    type Service = ExpectHandler;
-    type InitError = Error;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &ServerConfig) -> Self::Future {
-        ok(ExpectHandler)
-    }
-}
-
-impl Service for ExpectHandler {
-    type Request = Request;
-    type Response = Request;
-    type Error = Error;
-    type Future = FutureResult<Self::Response, Self::Error>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Request) -> Self::Future {
-        ok(req)
-    }
-}
--- a/actix-http/src/h1/mod.rs
+++ b/actix-http/src/h1/mod.rs
@@ -1,85 +0,0 @@
-//! HTTP/1 implementation
-use bytes::{Bytes, BytesMut};
-
-mod client;
-mod codec;
-mod decoder;
-mod dispatcher;
-mod encoder;
-mod expect;
-mod payload;
-mod service;
-mod upgrade;
-mod utils;
-
-pub use self::client::{ClientCodec, ClientPayloadCodec};
-pub use self::codec::Codec;
-pub use self::dispatcher::Dispatcher;
-pub use self::expect::ExpectHandler;
-pub use self::payload::Payload;
-pub use self::service::{H1Service, H1ServiceHandler, OneRequest};
-pub use self::upgrade::UpgradeHandler;
-pub use self::utils::SendResponse;
-
-#[derive(Debug)]
-/// Codec message
-pub enum Message<T> {
-    /// Http message
-    Item(T),
-    /// Payload chunk
-    Chunk(Option<Bytes>),
-}
-
-impl<T> From<T> for Message<T> {
-    fn from(item: T) -> Self {
-        Message::Item(item)
-    }
-}
-
-/// Incoming request type
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MessageType {
-    None,
-    Payload,
-    Stream,
-}
-
-const LW: usize = 2 * 1024;
-const HW: usize = 32 * 1024;
-
-pub(crate) fn reserve_readbuf(src: &mut BytesMut) {
-    let cap = src.capacity();
-    if cap < LW {
-        src.reserve(HW - cap);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::request::Request;
-
-    impl Message<Request> {
-        pub fn message(self) -> Request {
-            match self {
-                Message::Item(req) => req,
-                _ => panic!("error"),
-            }
-        }
-
-        pub fn chunk(self) -> Bytes {
-            match self {
-                Message::Chunk(Some(data)) => data,
-                _ => panic!("error"),
-            }
-        }
-
-        pub fn eof(self) -> bool {
-            match self {
-                Message::Chunk(None) => true,
-                Message::Chunk(Some(_)) => false,
-                _ => panic!("error"),
-            }
-        }
-    }
-}
--- a/actix-http/src/h1/payload.rs
+++ b/actix-http/src/h1/payload.rs
@@ -1,254 +0,0 @@
-//! Payload stream
-use std::cell::RefCell;
-use std::collections::VecDeque;
-use std::rc::{Rc, Weak};
-
-use bytes::Bytes;
-use futures::task::current as current_task;
-use futures::task::Task;
-use futures::{Async, Poll, Stream};
-
-use crate::error::PayloadError;
-
-/// max buffer size 32k
-pub(crate) const MAX_BUFFER_SIZE: usize = 32_768;
-
-#[derive(Debug, PartialEq)]
-pub enum PayloadStatus {
-    Read,
-    Pause,
-    Dropped,
-}
-
-/// Buffered stream of bytes chunks
-///
-/// Payload stores chunks in a vector. First chunk can be received with
-/// `.readany()` method. Payload stream is not thread safe. Payload does not
-/// notify current task when new data is available.
-///
-/// Payload stream can be used as `Response` body stream.
-#[derive(Debug)]
-pub struct Payload {
-    inner: Rc<RefCell<Inner>>,
-}
-
-impl Payload {
-    /// Create payload stream.
-    ///
-    /// This method construct two objects responsible for bytes stream
-    /// generation.
-    ///
-    /// * `PayloadSender` - *Sender* side of the stream
-    ///
-    /// * `Payload` - *Receiver* side of the stream
-    pub fn create(eof: bool) -> (PayloadSender, Payload) {
-        let shared = Rc::new(RefCell::new(Inner::new(eof)));
-
-        (
-            PayloadSender {
-                inner: Rc::downgrade(&shared),
-            },
-            Payload { inner: shared },
-        )
-    }
-
-    /// Create empty payload
-    #[doc(hidden)]
-    pub fn empty() -> Payload {
-        Payload {
-            inner: Rc::new(RefCell::new(Inner::new(true))),
-        }
-    }
-
-    /// Length of the data in this payload
-    #[cfg(test)]
-    pub fn len(&self) -> usize {
-        self.inner.borrow().len()
-    }
-
-    /// Is payload empty
-    #[cfg(test)]
-    pub fn is_empty(&self) -> bool {
-        self.inner.borrow().len() == 0
-    }
-
-    /// Put unused data back to payload
-    #[inline]
-    pub fn unread_data(&mut self, data: Bytes) {
-        self.inner.borrow_mut().unread_data(data);
-    }
-}
-
-impl Stream for Payload {
-    type Item = Bytes;
-    type Error = PayloadError;
-
-    #[inline]
-    fn poll(&mut self) -> Poll<Option<Bytes>, PayloadError> {
-        self.inner.borrow_mut().readany()
-    }
-}
-
-/// Sender part of the payload stream
-pub struct PayloadSender {
-    inner: Weak<RefCell<Inner>>,
-}
-
-impl PayloadSender {
-    #[inline]
-    pub fn set_error(&mut self, err: PayloadError) {
-        if let Some(shared) = self.inner.upgrade() {
-            shared.borrow_mut().set_error(err)
-        }
-    }
-
-    #[inline]
-    pub fn feed_eof(&mut self) {
-        if let Some(shared) = self.inner.upgrade() {
-            shared.borrow_mut().feed_eof()
-        }
-    }
-
-    #[inline]
-    pub fn feed_data(&mut self, data: Bytes) {
-        if let Some(shared) = self.inner.upgrade() {
-            shared.borrow_mut().feed_data(data)
-        }
-    }
-
-    #[inline]
-    pub fn need_read(&self) -> PayloadStatus {
-        // we check need_read only if Payload (other side) is alive,
-        // otherwise always return true (consume payload)
-        if let Some(shared) = self.inner.upgrade() {
-            if shared.borrow().need_read {
-                PayloadStatus::Read
-            } else {
-                #[cfg(not(test))]
-                {
-                    if shared.borrow_mut().io_task.is_none() {
-                        shared.borrow_mut().io_task = Some(current_task());
-                    }
-                }
-                PayloadStatus::Pause
-            }
-        } else {
-            PayloadStatus::Dropped
-        }
-    }
-}
-
-#[derive(Debug)]
-struct Inner {
-    len: usize,
-    eof: bool,
-    err: Option<PayloadError>,
-    need_read: bool,
-    items: VecDeque<Bytes>,
-    task: Option<Task>,
-    io_task: Option<Task>,
-}
-
-impl Inner {
-    fn new(eof: bool) -> Self {
-        Inner {
-            eof,
-            len: 0,
-            err: None,
-            items: VecDeque::new(),
-            need_read: true,
-            task: None,
-            io_task: None,
-        }
-    }
-
-    #[inline]
-    fn set_error(&mut self, err: PayloadError) {
-        self.err = Some(err);
-    }
-
-    #[inline]
-    fn feed_eof(&mut self) {
-        self.eof = true;
-    }
-
-    #[inline]
-    fn feed_data(&mut self, data: Bytes) {
-        self.len += data.len();
-        self.items.push_back(data);
-        self.need_read = self.len < MAX_BUFFER_SIZE;
-        if let Some(task) = self.task.take() {
-            task.notify()
-        }
-    }
-
-    #[cfg(test)]
-    fn len(&self) -> usize {
-        self.len
-    }
-
-    fn readany(&mut self) -> Poll<Option<Bytes>, PayloadError> {
-        if let Some(data) = self.items.pop_front() {
-            self.len -= data.len();
-            self.need_read = self.len < MAX_BUFFER_SIZE;
-
-            if self.need_read && self.task.is_none() && !self.eof {
-                self.task = Some(current_task());
-            }
-            if let Some(task) = self.io_task.take() {
-                task.notify()
-            }
-            Ok(Async::Ready(Some(data)))
-        } else if let Some(err) = self.err.take() {
-            Err(err)
-        } else if self.eof {
-            Ok(Async::Ready(None))
-        } else {
-            self.need_read = true;
-            #[cfg(not(test))]
-            {
-                if self.task.is_none() {
-                    self.task = Some(current_task());
-                }
-                if let Some(task) = self.io_task.take() {
-                    task.notify()
-                }
-            }
-            Ok(Async::NotReady)
-        }
-    }
-
-    fn unread_data(&mut self, data: Bytes) {
-        self.len += data.len();
-        self.items.push_front(data);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use actix_rt::Runtime;
-    use futures::future::{lazy, result};
-
-    #[test]
-    fn test_unread_data() {
-        Runtime::new()
-            .unwrap()
-            .block_on(lazy(|| {
-                let (_, mut payload) = Payload::create(false);
-
-                payload.unread_data(Bytes::from("data"));
-                assert!(!payload.is_empty());
-                assert_eq!(payload.len(), 4);
-
-                assert_eq!(
-                    Async::Ready(Some(Bytes::from("data"))),
-                    payload.poll().ok().unwrap()
-                );
-
-                let res: Result<(), ()> = Ok(());
-                result(res)
-            }))
-            .unwrap();
-    }
-}
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@@ -1,433 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-use std::rc::Rc;
-
-use actix_codec::Framed;
-use actix_server_config::{Io, IoStream, ServerConfig as SrvConfig};
-use actix_service::{IntoNewService, NewService, Service};
-use futures::future::{ok, FutureResult};
-use futures::{try_ready, Async, Future, IntoFuture, Poll, Stream};
-
-use crate::body::MessageBody;
-use crate::cloneable::CloneableService;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::{DispatchError, Error, ParseError};
-use crate::helpers::DataFactory;
-use crate::request::Request;
-use crate::response::Response;
-
-use super::codec::Codec;
-use super::dispatcher::Dispatcher;
-use super::{ExpectHandler, Message, UpgradeHandler};
-
-/// `NewService` implementation for HTTP1 transport
-pub struct H1Service<T, P, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
-    srv: S,
-    cfg: ServiceConfig,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B> H1Service<T, P, S, B>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    /// Create new `HttpService` instance with default config.
-    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
-        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);
-
-        H1Service {
-            cfg,
-            srv: service.into_new_service(),
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-
-    /// Create new `HttpService` instance with config.
-    pub fn with_config<F: IntoNewService<S>>(cfg: ServiceConfig, service: F) -> Self {
-        H1Service {
-            cfg,
-            srv: service.into_new_service(),
-            expect: ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P, S, B, X, U> H1Service<T, P, S, B, X, U>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-{
-    pub fn expect<X1>(self, expect: X1) -> H1Service<T, P, S, B, X1, U>
-    where
-        X1: NewService<Request = Request, Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-    {
-        H1Service {
-            expect,
-            cfg: self.cfg,
-            srv: self.srv,
-            upgrade: self.upgrade,
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, P, S, B, X, U1>
-    where
-        U1: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-    {
-        H1Service {
-            upgrade,
-            cfg: self.cfg,
-            srv: self.srv,
-            expect: self.expect,
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect(
-        mut self,
-        f: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> Self {
-        self.on_connect = f;
-        self
-    }
-}
-
-impl<T, P, S, B, X, U> NewService for H1Service<T, P, S, B, X, U>
-where
-    T: IoStream,
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: NewService<
-        Config = SrvConfig,
-        Request = (Request, Framed<T, Codec>),
-        Response = (),
-    >,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    type Config = SrvConfig;
-    type Request = Io<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type InitError = ();
-    type Service = H1ServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
-    type Future = H1ServiceResponse<T, P, S, B, X, U>;
-
-    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
-        H1ServiceResponse {
-            fut: self.srv.new_service(cfg).into_future(),
-            fut_ex: Some(self.expect.new_service(cfg)),
-            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
-            expect: None,
-            upgrade: None,
-            on_connect: self.on_connect.clone(),
-            cfg: Some(self.cfg.clone()),
-            _t: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct H1ServiceResponse<T, P, S, B, X, U>
-where
-    S: NewService<Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    X: NewService<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    fut: S::Future,
-    fut_ex: Option<X::Future>,
-    fut_upg: Option<U::Future>,
-    expect: Option<X::Service>,
-    upgrade: Option<U::Service>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    cfg: Option<ServiceConfig>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B, X, U> Future for H1ServiceResponse<T, P, S, B, X, U>
-where
-    T: IoStream,
-    S: NewService<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    S::InitError: fmt::Debug,
-    B: MessageBody,
-    X: NewService<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    type Item = H1ServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut_ex {
-            let expect = try_ready!(fut
-                .poll()
-                .map_err(|e| log::error!("Init http service error: {:?}", e)));
-            self.expect = Some(expect);
-            self.fut_ex.take();
-        }
-
-        if let Some(ref mut fut) = self.fut_upg {
-            let upgrade = try_ready!(fut
-                .poll()
-                .map_err(|e| log::error!("Init http service error: {:?}", e)));
-            self.upgrade = Some(upgrade);
-            self.fut_ex.take();
-        }
-
-        let service = try_ready!(self
-            .fut
-            .poll()
-            .map_err(|e| log::error!("Init http service error: {:?}", e)));
-        Ok(Async::Ready(H1ServiceHandler::new(
-            self.cfg.take().unwrap(),
-            service,
-            self.expect.take().unwrap(),
-            self.upgrade.take(),
-            self.on_connect.clone(),
-        )))
-    }
-}
-
-/// `Service` implementation for HTTP1 transport
-pub struct H1ServiceHandler<T, P, S, B, X, U> {
-    srv: CloneableService<S>,
-    expect: CloneableService<X>,
-    upgrade: Option<CloneableService<U>>,
-    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    cfg: ServiceConfig,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B, X, U> H1ServiceHandler<T, P, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn new(
-        cfg: ServiceConfig,
-        srv: S,
-        expect: X,
-        upgrade: Option<U>,
-        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> H1ServiceHandler<T, P, S, B, X, U> {
-        H1ServiceHandler {
-            srv: CloneableService::new(srv),
-            expect: CloneableService::new(expect),
-            upgrade: upgrade.map(CloneableService::new),
-            cfg,
-            on_connect,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P, S, B, X, U> Service for H1ServiceHandler<T, P, S, B, X, U>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    type Request = Io<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type Future = Dispatcher<T, S, B, X, U>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        let ready = self
-            .expect
-            .poll_ready()
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready();
-
-        let ready = self
-            .srv
-            .poll_ready()
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready()
-            && ready;
-
-        if ready {
-            Ok(Async::Ready(()))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let io = req.into_parts().0;
-
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
-
-        Dispatcher::new(
-            io,
-            self.cfg.clone(),
-            self.srv.clone(),
-            self.expect.clone(),
-            self.upgrade.clone(),
-            on_connect,
-        )
-    }
-}
-
-/// `NewService` implementation for `OneRequestService` service
-#[derive(Default)]
-pub struct OneRequest<T, P> {
-    config: ServiceConfig,
-    _t: PhantomData<(T, P)>,
-}
-
-impl<T, P> OneRequest<T, P>
-where
-    T: IoStream,
-{
-    /// Create new `H1SimpleService` instance.
-    pub fn new() -> Self {
-        OneRequest {
-            config: ServiceConfig::default(),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P> NewService for OneRequest<T, P>
-where
-    T: IoStream,
-{
-    type Config = SrvConfig;
-    type Request = Io<T, P>;
-    type Response = (Request, Framed<T, Codec>);
-    type Error = ParseError;
-    type InitError = ();
-    type Service = OneRequestService<T, P>;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &SrvConfig) -> Self::Future {
-        ok(OneRequestService {
-            config: self.config.clone(),
-            _t: PhantomData,
-        })
-    }
-}
-
-/// `Service` implementation for HTTP1 transport. Reads one request and returns
-/// request and framed object.
-pub struct OneRequestService<T, P> {
-    config: ServiceConfig,
-    _t: PhantomData<(T, P)>,
-}
-
-impl<T, P> Service for OneRequestService<T, P>
-where
-    T: IoStream,
-{
-    type Request = Io<T, P>;
-    type Response = (Request, Framed<T, Codec>);
-    type Error = ParseError;
-    type Future = OneRequestServiceResponse<T>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        OneRequestServiceResponse {
-            framed: Some(Framed::new(
-                req.into_parts().0,
-                Codec::new(self.config.clone()),
-            )),
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct OneRequestServiceResponse<T>
-where
-    T: IoStream,
-{
-    framed: Option<Framed<T, Codec>>,
-}
-
-impl<T> Future for OneRequestServiceResponse<T>
-where
-    T: IoStream,
-{
-    type Item = (Request, Framed<T, Codec>);
-    type Error = ParseError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.framed.as_mut().unwrap().poll()? {
-            Async::Ready(Some(req)) => match req {
-                Message::Item(req) => {
-                    Ok(Async::Ready((req, self.framed.take().unwrap())))
-                }
-                Message::Chunk(_) => unreachable!("Something is wrong"),
-            },
-            Async::Ready(None) => Err(ParseError::Incomplete),
-            Async::NotReady => Ok(Async::NotReady),
-        }
-    }
-}
--- a/actix-http/src/h1/upgrade.rs
+++ b/actix-http/src/h1/upgrade.rs
@@ -1,42 +0,0 @@
-use std::marker::PhantomData;
-
-use actix_codec::Framed;
-use actix_server_config::ServerConfig;
-use actix_service::{NewService, Service};
-use futures::future::FutureResult;
-use futures::{Async, Poll};
-
-use crate::error::Error;
-use crate::h1::Codec;
-use crate::request::Request;
-
-pub struct UpgradeHandler<T>(PhantomData<T>);
-
-impl<T> NewService for UpgradeHandler<T> {
-    type Config = ServerConfig;
-    type Request = (Request, Framed<T, Codec>);
-    type Response = ();
-    type Error = Error;
-    type Service = UpgradeHandler<T>;
-    type InitError = Error;
-    type Future = FutureResult<Self::Service, Self::InitError>;
-
-    fn new_service(&self, _: &ServerConfig) -> Self::Future {
-        unimplemented!()
-    }
-}
-
-impl<T> Service for UpgradeHandler<T> {
-    type Request = (Request, Framed<T, Codec>);
-    type Response = ();
-    type Error = Error;
-    type Future = FutureResult<Self::Response, Self::Error>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        Ok(Async::Ready(()))
-    }
-
-    fn call(&mut self, _: Self::Request) -> Self::Future {
-        unimplemented!()
-    }
-}
--- a/actix-http/src/h1/utils.rs
+++ b/actix-http/src/h1/utils.rs
@@ -1,92 +0,0 @@
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use futures::{Async, Future, Poll, Sink};
-
-use crate::body::{BodySize, MessageBody, ResponseBody};
-use crate::error::Error;
-use crate::h1::{Codec, Message};
-use crate::response::Response;
-
-/// Send http/1 response
-pub struct SendResponse<T, B> {
-    res: Option<Message<(Response<()>, BodySize)>>,
-    body: Option<ResponseBody<B>>,
-    framed: Option<Framed<T, Codec>>,
-}
-
-impl<T, B> SendResponse<T, B>
-where
-    B: MessageBody,
-{
-    pub fn new(framed: Framed<T, Codec>, response: Response<B>) -> Self {
-        let (res, body) = response.into_parts();
-
-        SendResponse {
-            res: Some((res, body.size()).into()),
-            body: Some(body),
-            framed: Some(framed),
-        }
-    }
-}
-
-impl<T, B> Future for SendResponse<T, B>
-where
-    T: AsyncRead + AsyncWrite,
-    B: MessageBody,
-{
-    type Item = Framed<T, Codec>;
-    type Error = Error;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            let mut body_ready = self.body.is_some();
-            let framed = self.framed.as_mut().unwrap();
-
-            // send body
-            if self.res.is_none() && self.body.is_some() {
-                while body_ready && self.body.is_some() && !framed.is_write_buf_full() {
-                    match self.body.as_mut().unwrap().poll_next()? {
-                        Async::Ready(item) => {
-                            // body is done
-                            if item.is_none() {
-                                let _ = self.body.take();
-                            }
-                            framed.force_send(Message::Chunk(item))?;
-                        }
-                        Async::NotReady => body_ready = false,
-                    }
-                }
-            }
-
-            // flush write buffer
-            if !framed.is_write_buf_empty() {
-                match framed.poll_complete()? {
-                    Async::Ready(_) => {
-                        if body_ready {
-                            continue;
-                        } else {
-                            return Ok(Async::NotReady);
-                        }
-                    }
-                    Async::NotReady => return Ok(Async::NotReady),
-                }
-            }
-
-            // send response
-            if let Some(res) = self.res.take() {
-                framed.force_send(res)?;
-                continue;
-            }
-
-            if self.body.is_some() {
-                if body_ready {
-                    continue;
-                } else {
-                    return Ok(Async::NotReady);
-                }
-            } else {
-                break;
-            }
-        }
-        Ok(Async::Ready(self.framed.take().unwrap()))
-    }
-}
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@@ -1,336 +0,0 @@
-use std::collections::VecDeque;
-use std::marker::PhantomData;
-use std::time::Instant;
-use std::{fmt, mem, net};
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_server_config::IoStream;
-use actix_service::Service;
-use bitflags::bitflags;
-use bytes::{Bytes, BytesMut};
-use futures::{try_ready, Async, Future, Poll, Sink, Stream};
-use h2::server::{Connection, SendResponse};
-use h2::{RecvStream, SendStream};
-use http::header::{
-    HeaderValue, ACCEPT_ENCODING, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING,
-};
-use http::HttpTryFrom;
-use log::{debug, error, trace};
-use tokio_timer::Delay;
-
-use crate::body::{Body, BodySize, MessageBody, ResponseBody};
-use crate::cloneable::CloneableService;
-use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error, ParseError, PayloadError, ResponseError};
-use crate::helpers::DataFactory;
-use crate::httpmessage::HttpMessage;
-use crate::message::ResponseHead;
-use crate::payload::Payload;
-use crate::request::Request;
-use crate::response::Response;
-
-const CHUNK_SIZE: usize = 16_384;
-
-/// Dispatcher for HTTP/2 protocol
-pub struct Dispatcher<T: IoStream, S: Service<Request = Request>, B: MessageBody> {
-    service: CloneableService<S>,
-    connection: Connection<T, Bytes>,
-    on_connect: Option<Box<dyn DataFactory>>,
-    config: ServiceConfig,
-    peer_addr: Option<net::SocketAddr>,
-    ka_expire: Instant,
-    ka_timer: Option<Delay>,
-    _t: PhantomData<B>,
-}
-
-impl<T, S, B> Dispatcher<T, S, B>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    pub(crate) fn new(
-        service: CloneableService<S>,
-        connection: Connection<T, Bytes>,
-        on_connect: Option<Box<dyn DataFactory>>,
-        config: ServiceConfig,
-        timeout: Option<Delay>,
-        peer_addr: Option<net::SocketAddr>,
-    ) -> Self {
-        // let keepalive = config.keep_alive_enabled();
-        // let flags = if keepalive {
-        // Flags::KEEPALIVE | Flags::KEEPALIVE_ENABLED
-        // } else {
-        //     Flags::empty()
-        // };
-
-        // keep-alive timer
-        let (ka_expire, ka_timer) = if let Some(delay) = timeout {
-            (delay.deadline(), Some(delay))
-        } else if let Some(delay) = config.keep_alive_timer() {
-            (delay.deadline(), Some(delay))
-        } else {
-            (config.now(), None)
-        };
-
-        Dispatcher {
-            service,
-            config,
-            peer_addr,
-            connection,
-            on_connect,
-            ka_expire,
-            ka_timer,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, S, B> Future for Dispatcher<T, S, B>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    type Item = ();
-    type Error = DispatchError;
-
-    #[inline]
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        loop {
-            match self.connection.poll()? {
-                Async::Ready(None) => return Ok(Async::Ready(())),
-                Async::Ready(Some((req, res))) => {
-                    // update keep-alive expire
-                    if self.ka_timer.is_some() {
-                        if let Some(expire) = self.config.keep_alive_expire() {
-                            self.ka_expire = expire;
-                        }
-                    }
-
-                    let (parts, body) = req.into_parts();
-                    let mut req = Request::with_payload(body.into());
-
-                    let head = &mut req.head_mut();
-                    head.uri = parts.uri;
-                    head.method = parts.method;
-                    head.version = parts.version;
-                    head.headers = parts.headers.into();
-                    head.peer_addr = self.peer_addr;
-
-                    // set on_connect data
-                    if let Some(ref on_connect) = self.on_connect {
-                        on_connect.set(&mut req.extensions_mut());
-                    }
-
-                    tokio_current_thread::spawn(ServiceResponse::<S::Future, B> {
-                        state: ServiceResponseState::ServiceCall(
-                            self.service.call(req),
-                            Some(res),
-                        ),
-                        config: self.config.clone(),
-                        buffer: None,
-                    })
-                }
-                Async::NotReady => return Ok(Async::NotReady),
-            }
-        }
-    }
-}
-
-struct ServiceResponse<F, B> {
-    state: ServiceResponseState<F, B>,
-    config: ServiceConfig,
-    buffer: Option<Bytes>,
-}
-
-enum ServiceResponseState<F, B> {
-    ServiceCall(F, Option<SendResponse<Bytes>>),
-    SendPayload(SendStream<Bytes>, ResponseBody<B>),
-}
-
-impl<F, B> ServiceResponse<F, B>
-where
-    F: Future,
-    F::Error: Into<Error>,
-    F::Item: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    fn prepare_response(
-        &self,
-        head: &ResponseHead,
-        size: &mut BodySize,
-    ) -> http::Response<()> {
-        let mut has_date = false;
-        let mut skip_len = size != &BodySize::Stream;
-
-        let mut res = http::Response::new(());
-        *res.status_mut() = head.status;
-        *res.version_mut() = http::Version::HTTP_2;
-
-        // Content length
-        match head.status {
-            http::StatusCode::NO_CONTENT
-            | http::StatusCode::CONTINUE
-            | http::StatusCode::PROCESSING => *size = BodySize::None,
-            http::StatusCode::SWITCHING_PROTOCOLS => {
-                skip_len = true;
-                *size = BodySize::Stream;
-            }
-            _ => (),
-        }
-        let _ = match size {
-            BodySize::None | BodySize::Stream => None,
-            BodySize::Empty => res
-                .headers_mut()
-                .insert(CONTENT_LENGTH, HeaderValue::from_static("0")),
-            BodySize::Sized(len) => res.headers_mut().insert(
-                CONTENT_LENGTH,
-                HeaderValue::try_from(format!("{}", len)).unwrap(),
-            ),
-            BodySize::Sized64(len) => res.headers_mut().insert(
-                CONTENT_LENGTH,
-                HeaderValue::try_from(format!("{}", len)).unwrap(),
-            ),
-        };
-
-        // copy headers
-        for (key, value) in head.headers.iter() {
-            match *key {
-                CONNECTION | TRANSFER_ENCODING => continue, // http2 specific
-                CONTENT_LENGTH if skip_len => continue,
-                DATE => has_date = true,
-                _ => (),
-            }
-            res.headers_mut().append(key, value.clone());
-        }
-
-        // set date header
-        if !has_date {
-            let mut bytes = BytesMut::with_capacity(29);
-            self.config.set_date_header(&mut bytes);
-            res.headers_mut()
-                .insert(DATE, HeaderValue::try_from(bytes.freeze()).unwrap());
-        }
-
-        res
-    }
-}
-
-impl<F, B> Future for ServiceResponse<F, B>
-where
-    F: Future,
-    F::Error: Into<Error>,
-    F::Item: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.state {
-            ServiceResponseState::ServiceCall(ref mut call, ref mut send) => {
-                match call.poll() {
-                    Ok(Async::Ready(res)) => {
-                        let (res, body) = res.into().replace_body(());
-
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res = self.prepare_response(res.head(), &mut size);
-
-                        let stream =
-                            send.send_response(h2_res, size.is_eof()).map_err(|e| {
-                                trace!("Error sending h2 response: {:?}", e);
-                            })?;
-
-                        if size.is_eof() {
-                            Ok(Async::Ready(()))
-                        } else {
-                            self.state = ServiceResponseState::SendPayload(stream, body);
-                            self.poll()
-                        }
-                    }
-                    Ok(Async::NotReady) => Ok(Async::NotReady),
-                    Err(e) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-
-                        let mut send = send.take().unwrap();
-                        let mut size = body.size();
-                        let h2_res = self.prepare_response(res.head(), &mut size);
-
-                        let stream =
-                            send.send_response(h2_res, size.is_eof()).map_err(|e| {
-                                trace!("Error sending h2 response: {:?}", e);
-                            })?;
-
-                        if size.is_eof() {
-                            Ok(Async::Ready(()))
-                        } else {
-                            self.state = ServiceResponseState::SendPayload(
-                                stream,
-                                body.into_body(),
-                            );
-                            self.poll()
-                        }
-                    }
-                }
-            }
-            ServiceResponseState::SendPayload(ref mut stream, ref mut body) => loop {
-                loop {
-                    if let Some(ref mut buffer) = self.buffer {
-                        match stream.poll_capacity().map_err(|e| warn!("{:?}", e))? {
-                            Async::NotReady => return Ok(Async::NotReady),
-                            Async::Ready(None) => return Ok(Async::Ready(())),
-                            Async::Ready(Some(cap)) => {
-                                let len = buffer.len();
-                                let bytes = buffer.split_to(std::cmp::min(cap, len));
-
-                                if let Err(e) = stream.send_data(bytes, false) {
-                                    warn!("{:?}", e);
-                                    return Err(());
-                                } else if !buffer.is_empty() {
-                                    let cap = std::cmp::min(buffer.len(), CHUNK_SIZE);
-                                    stream.reserve_capacity(cap);
-                                } else {
-                                    self.buffer.take();
-                                }
-                            }
-                        }
-                    } else {
-                        match body.poll_next() {
-                            Ok(Async::NotReady) => {
-                                return Ok(Async::NotReady);
-                            }
-                            Ok(Async::Ready(None)) => {
-                                if let Err(e) = stream.send_data(Bytes::new(), true) {
-                                    warn!("{:?}", e);
-                                    return Err(());
-                                } else {
-                                    return Ok(Async::Ready(()));
-                                }
-                            }
-                            Ok(Async::Ready(Some(chunk))) => {
-                                stream.reserve_capacity(std::cmp::min(
-                                    chunk.len(),
-                                    CHUNK_SIZE,
-                                ));
-                                self.buffer = Some(chunk);
-                            }
-                            Err(e) => {
-                                error!("Response payload stream error: {:?}", e);
-                                return Err(());
-                            }
-                        }
-                    }
-                }
-            },
-        }
-    }
-}
--- a/actix-http/src/h2/mod.rs
+++ b/actix-http/src/h2/mod.rs
@@ -1,46 +0,0 @@
-#![allow(dead_code, unused_imports)]
-
-use std::fmt;
-
-use bytes::Bytes;
-use futures::{Async, Poll, Stream};
-use h2::RecvStream;
-
-mod dispatcher;
-mod service;
-
-pub use self::dispatcher::Dispatcher;
-pub use self::service::H2Service;
-use crate::error::PayloadError;
-
-/// H2 receive stream
-pub struct Payload {
-    pl: RecvStream,
-}
-
-impl Payload {
-    pub(crate) fn new(pl: RecvStream) -> Self {
-        Self { pl }
-    }
-}
-
-impl Stream for Payload {
-    type Item = Bytes;
-    type Error = PayloadError;
-
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        match self.pl.poll() {
-            Ok(Async::Ready(Some(chunk))) => {
-                let len = chunk.len();
-                if let Err(err) = self.pl.release_capacity().release_capacity(len) {
-                    Err(err.into())
-                } else {
-                    Ok(Async::Ready(Some(chunk)))
-                }
-            }
-            Ok(Async::Ready(None)) => Ok(Async::Ready(None)),
-            Ok(Async::NotReady) => Ok(Async::NotReady),
-            Err(err) => Err(err.into()),
-        }
-    }
-}
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@@ -1,271 +0,0 @@
-use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::{io, net, rc};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_server_config::{Io, IoStream, ServerConfig as SrvConfig};
-use actix_service::{IntoNewService, NewService, Service};
-use bytes::Bytes;
-use futures::future::{ok, FutureResult};
-use futures::{try_ready, Async, Future, IntoFuture, Poll, Stream};
-use h2::server::{self, Connection, Handshake};
-use h2::RecvStream;
-use log::error;
-
-use crate::body::MessageBody;
-use crate::cloneable::CloneableService;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::{DispatchError, Error, ParseError, ResponseError};
-use crate::helpers::DataFactory;
-use crate::payload::Payload;
-use crate::request::Request;
-use crate::response::Response;
-
-use super::dispatcher::Dispatcher;
-
-/// `NewService` implementation for HTTP2 transport
-pub struct H2Service<T, P, S, B> {
-    srv: S,
-    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B> H2Service<T, P, S, B>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create new `HttpService` instance.
-    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
-        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);
-
-        H2Service {
-            cfg,
-            on_connect: None,
-            srv: service.into_new_service(),
-            _t: PhantomData,
-        }
-    }
-
-    /// Create new `HttpService` instance with config.
-    pub fn with_config<F: IntoNewService<S>>(cfg: ServiceConfig, service: F) -> Self {
-        H2Service {
-            cfg,
-            on_connect: None,
-            srv: service.into_new_service(),
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect(
-        mut self,
-        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> Self {
-        self.on_connect = f;
-        self
-    }
-}
-
-impl<T, P, S, B> NewService for H2Service<T, P, S, B>
-where
-    T: IoStream,
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    type Config = SrvConfig;
-    type Request = Io<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type InitError = S::InitError;
-    type Service = H2ServiceHandler<T, P, S::Service, B>;
-    type Future = H2ServiceResponse<T, P, S, B>;
-
-    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
-        H2ServiceResponse {
-            fut: self.srv.new_service(cfg).into_future(),
-            cfg: Some(self.cfg.clone()),
-            on_connect: self.on_connect.clone(),
-            _t: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct H2ServiceResponse<T, P, S: NewService, B> {
-    fut: <S::Future as IntoFuture>::Future,
-    cfg: Option<ServiceConfig>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B> Future for H2ServiceResponse<T, P, S, B>
-where
-    T: IoStream,
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::Response: Into<Response<B>>,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    type Item = H2ServiceHandler<T, P, S::Service, B>;
-    type Error = S::InitError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        let service = try_ready!(self.fut.poll());
-        Ok(Async::Ready(H2ServiceHandler::new(
-            self.cfg.take().unwrap(),
-            self.on_connect.clone(),
-            service,
-        )))
-    }
-}
-
-/// `Service` implementation for http/2 transport
-pub struct H2ServiceHandler<T, P, S, B> {
-    srv: CloneableService<S>,
-    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B> H2ServiceHandler<T, P, S, B>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    fn new(
-        cfg: ServiceConfig,
-        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-        srv: S,
-    ) -> H2ServiceHandler<T, P, S, B> {
-        H2ServiceHandler {
-            cfg,
-            on_connect,
-            srv: CloneableService::new(srv),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P, S, B> Service for H2ServiceHandler<T, P, S, B>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    type Request = Io<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type Future = H2ServiceHandlerResponse<T, S, B>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        self.srv.poll_ready().map_err(|e| {
-            let e = e.into();
-            error!("Service readiness error: {:?}", e);
-            DispatchError::Service(e)
-        })
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let io = req.into_parts().0;
-        let peer_addr = io.peer_addr();
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
-
-        H2ServiceHandlerResponse {
-            state: State::Handshake(
-                Some(self.srv.clone()),
-                Some(self.cfg.clone()),
-                peer_addr,
-                on_connect,
-                server::handshake(io),
-            ),
-        }
-    }
-}
-
-enum State<T: IoStream, S: Service<Request = Request>, B: MessageBody>
-where
-    S::Future: 'static,
-{
-    Incoming(Dispatcher<T, S, B>),
-    Handshake(
-        Option<CloneableService<S>>,
-        Option<ServiceConfig>,
-        Option<net::SocketAddr>,
-        Option<Box<dyn DataFactory>>,
-        Handshake<T, Bytes>,
-    ),
-}
-
-pub struct H2ServiceHandlerResponse<T, S, B>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-{
-    state: State<T, S, B>,
-}
-
-impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    type Item = ();
-    type Error = DispatchError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.state {
-            State::Incoming(ref mut disp) => disp.poll(),
-            State::Handshake(
-                ref mut srv,
-                ref mut config,
-                ref peer_addr,
-                ref mut on_connect,
-                ref mut handshake,
-            ) => match handshake.poll() {
-                Ok(Async::Ready(conn)) => {
-                    self.state = State::Incoming(Dispatcher::new(
-                        srv.take().unwrap(),
-                        conn,
-                        on_connect.take(),
-                        config.take().unwrap(),
-                        None,
-                        *peer_addr,
-                    ));
-                    self.poll()
-                }
-                Ok(Async::NotReady) => Ok(Async::NotReady),
-                Err(err) => {
-                    trace!("H2 handshake error: {}", err);
-                    Err(err.into())
-                }
-            },
-        }
-    }
-}
--- a/actix-http/src/header/common/content_disposition.rs
+++ b/actix-http/src/header/common/content_disposition.rs
@@ -1,995 +0,0 @@
-// # References
-//
-// "The Content-Disposition Header Field" https://www.ietf.org/rfc/rfc2183.txt
-// "The Content-Disposition Header Field in the Hypertext Transfer Protocol (HTTP)" https://www.ietf.org/rfc/rfc6266.txt
-// "Returning Values from Forms: multipart/form-data" https://www.ietf.org/rfc/rfc7578.txt
-// Browser conformance tests at: http://greenbytes.de/tech/tc2231/
-// IANA assignment: http://www.iana.org/assignments/cont-disp/cont-disp.xhtml
-
-use lazy_static::lazy_static;
-use regex::Regex;
-use std::fmt::{self, Write};
-
-use crate::header::{self, ExtendedValue, Header, IntoHeaderValue, Writer};
-
-/// Split at the index of the first `needle` if it exists or at the end.
-fn split_once(haystack: &str, needle: char) -> (&str, &str) {
-    haystack.find(needle).map_or_else(
-        || (haystack, ""),
-        |sc| {
-            let (first, last) = haystack.split_at(sc);
-            (first, last.split_at(1).1)
-        },
-    )
-}
-
-/// Split at the index of the first `needle` if it exists or at the end, trim the right of the
-/// first part and the left of the last part.
-fn split_once_and_trim(haystack: &str, needle: char) -> (&str, &str) {
-    let (first, last) = split_once(haystack, needle);
-    (first.trim_end(), last.trim_start())
-}
-
-/// The implied disposition of the content of the HTTP body.
-#[derive(Clone, Debug, PartialEq)]
-pub enum DispositionType {
-    /// Inline implies default processing
-    Inline,
-    /// Attachment implies that the recipient should prompt the user to save the response locally,
-    /// rather than process it normally (as per its media type).
-    Attachment,
-    /// Used in *multipart/form-data* as defined in
-    /// [RFC7578](https://tools.ietf.org/html/rfc7578) to carry the field name and the file name.
-    FormData,
-    /// Extension type. Should be handled by recipients the same way as Attachment
-    Ext(String),
-}
-
-impl<'a> From<&'a str> for DispositionType {
-    fn from(origin: &'a str) -> DispositionType {
-        if origin.eq_ignore_ascii_case("inline") {
-            DispositionType::Inline
-        } else if origin.eq_ignore_ascii_case("attachment") {
-            DispositionType::Attachment
-        } else if origin.eq_ignore_ascii_case("form-data") {
-            DispositionType::FormData
-        } else {
-            DispositionType::Ext(origin.to_owned())
-        }
-    }
-}
-
-/// Parameter in [`ContentDisposition`].
-///
-/// # Examples
-/// ```
-/// use actix_http::http::header::DispositionParam;
-///
-/// let param = DispositionParam::Filename(String::from("sample.txt"));
-/// assert!(param.is_filename());
-/// assert_eq!(param.as_filename().unwrap(), "sample.txt");
-/// ```
-#[derive(Clone, Debug, PartialEq)]
-#[allow(clippy::large_enum_variant)]
-pub enum DispositionParam {
-    /// For [`DispositionType::FormData`] (i.e. *multipart/form-data*), the name of an field from
-    /// the form.
-    Name(String),
-    /// A plain file name.
-    ///
-    /// It is [not supposed](https://tools.ietf.org/html/rfc6266#appendix-D) to contain any
-    /// non-ASCII characters when used in a *Content-Disposition* HTTP response header, where
-    /// [`FilenameExt`](DispositionParam::FilenameExt) with charset UTF-8 may be used instead
-    /// in case there are Unicode characters in file names.
-    Filename(String),
-    /// An extended file name. It must not exist for `ContentType::Formdata` according to
-    /// [RFC7578 Section 4.2](https://tools.ietf.org/html/rfc7578#section-4.2).
-    FilenameExt(ExtendedValue),
-    /// An unrecognized regular parameter as defined in
-    /// [RFC5987](https://tools.ietf.org/html/rfc5987) as *reg-parameter*, in
-    /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *token "=" value*. Recipients should
-    /// ignore unrecognizable parameters.
-    Unknown(String, String),
-    /// An unrecognized extended paramater as defined in
-    /// [RFC5987](https://tools.ietf.org/html/rfc5987) as *ext-parameter*, in
-    /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *ext-token "=" ext-value*. The single
-    /// trailling asterisk is not included. Recipients should ignore unrecognizable parameters.
-    UnknownExt(String, ExtendedValue),
-}
-
-impl DispositionParam {
-    /// Returns `true` if the paramater is [`Name`](DispositionParam::Name).
-    #[inline]
-    pub fn is_name(&self) -> bool {
-        self.as_name().is_some()
-    }
-
-    /// Returns `true` if the paramater is [`Filename`](DispositionParam::Filename).
-    #[inline]
-    pub fn is_filename(&self) -> bool {
-        self.as_filename().is_some()
-    }
-
-    /// Returns `true` if the paramater is [`FilenameExt`](DispositionParam::FilenameExt).
-    #[inline]
-    pub fn is_filename_ext(&self) -> bool {
-        self.as_filename_ext().is_some()
-    }
-
-    /// Returns `true` if the paramater is [`Unknown`](DispositionParam::Unknown) and the `name`
-    #[inline]
-    /// matches.
-    pub fn is_unknown<T: AsRef<str>>(&self, name: T) -> bool {
-        self.as_unknown(name).is_some()
-    }
-
-    /// Returns `true` if the paramater is [`UnknownExt`](DispositionParam::UnknownExt) and the
-    /// `name` matches.
-    #[inline]
-    pub fn is_unknown_ext<T: AsRef<str>>(&self, name: T) -> bool {
-        self.as_unknown_ext(name).is_some()
-    }
-
-    /// Returns the name if applicable.
-    #[inline]
-    pub fn as_name(&self) -> Option<&str> {
-        match self {
-            DispositionParam::Name(ref name) => Some(name.as_str()),
-            _ => None,
-        }
-    }
-
-    /// Returns the filename if applicable.
-    #[inline]
-    pub fn as_filename(&self) -> Option<&str> {
-        match self {
-            DispositionParam::Filename(ref filename) => Some(filename.as_str()),
-            _ => None,
-        }
-    }
-
-    /// Returns the filename* if applicable.
-    #[inline]
-    pub fn as_filename_ext(&self) -> Option<&ExtendedValue> {
-        match self {
-            DispositionParam::FilenameExt(ref value) => Some(value),
-            _ => None,
-        }
-    }
-
-    /// Returns the value of the unrecognized regular parameter if it is
-    /// [`Unknown`](DispositionParam::Unknown) and the `name` matches.
-    #[inline]
-    pub fn as_unknown<T: AsRef<str>>(&self, name: T) -> Option<&str> {
-        match self {
-            DispositionParam::Unknown(ref ext_name, ref value)
-                if ext_name.eq_ignore_ascii_case(name.as_ref()) =>
-            {
-                Some(value.as_str())
-            }
-            _ => None,
-        }
-    }
-
-    /// Returns the value of the unrecognized extended parameter if it is
-    /// [`Unknown`](DispositionParam::Unknown) and the `name` matches.
-    #[inline]
-    pub fn as_unknown_ext<T: AsRef<str>>(&self, name: T) -> Option<&ExtendedValue> {
-        match self {
-            DispositionParam::UnknownExt(ref ext_name, ref value)
-                if ext_name.eq_ignore_ascii_case(name.as_ref()) =>
-            {
-                Some(value)
-            }
-            _ => None,
-        }
-    }
-}
-
-/// A *Content-Disposition* header. It is compatible to be used either as
-/// [a response header for the main body](https://mdn.io/Content-Disposition#As_a_response_header_for_the_main_body)
-/// as (re)defined in [RFC6266](https://tools.ietf.org/html/rfc6266), or as
-/// [a header for a multipart body](https://mdn.io/Content-Disposition#As_a_header_for_a_multipart_body)
-/// as (re)defined in [RFC7587](https://tools.ietf.org/html/rfc7578).
-///
-/// In a regular HTTP response, the *Content-Disposition* response header is a header indicating if
-/// the content is expected to be displayed *inline* in the browser, that is, as a Web page or as
-/// part of a Web page, or as an attachment, that is downloaded and saved locally, and also can be
-/// used to attach additional metadata, such as the filename to use when saving the response payload
-/// locally.
-///
-/// In a *multipart/form-data* body, the HTTP *Content-Disposition* general header is a header that
-/// can be used on the subpart of a multipart body to give information about the field it applies to.
-/// The subpart is delimited by the boundary defined in the *Content-Type* header. Used on the body
-/// itself, *Content-Disposition* has no effect.
-///
-/// # ABNF
-
-/// ```text
-/// content-disposition = "Content-Disposition" ":"
-///                       disposition-type *( ";" disposition-parm )
-///
-/// disposition-type    = "inline" | "attachment" | disp-ext-type
-///                       ; case-insensitive
-///
-/// disp-ext-type       = token
-///
-/// disposition-parm    = filename-parm | disp-ext-parm
-///
-/// filename-parm       = "filename" "=" value
-///                     | "filename*" "=" ext-value
-///
-/// disp-ext-parm       = token "=" value
-///                     | ext-token "=" ext-value
-///
-/// ext-token           = <the characters in token, followed by "*">
-/// ```
-///
-/// # Note
-///
-/// filename is [not supposed](https://tools.ietf.org/html/rfc6266#appendix-D) to contain any
-/// non-ASCII characters when used in a *Content-Disposition* HTTP response header, where
-/// filename* with charset UTF-8 may be used instead in case there are Unicode characters in file
-/// names.
-/// filename is [acceptable](https://tools.ietf.org/html/rfc7578#section-4.2) to be UTF-8 encoded
-/// directly in a *Content-Disposition* header for *multipart/form-data*, though.
-///
-/// filename* [must not](https://tools.ietf.org/html/rfc7578#section-4.2) be used within
-/// *multipart/form-data*.
-///
-/// # Example
-///
-/// ```
-/// use actix_http::http::header::{
-///     Charset, ContentDisposition, DispositionParam, DispositionType,
-///     ExtendedValue,
-/// };
-///
-/// let cd1 = ContentDisposition {
-///     disposition: DispositionType::Attachment,
-///     parameters: vec![DispositionParam::FilenameExt(ExtendedValue {
-///         charset: Charset::Iso_8859_1, // The character set for the bytes of the filename
-///         language_tag: None, // The optional language tag (see `language-tag` crate)
-///         value: b"\xa9 Copyright 1989.txt".to_vec(), // the actual bytes of the filename
-///     })],
-/// };
-/// assert!(cd1.is_attachment());
-/// assert!(cd1.get_filename_ext().is_some());
-///
-/// let cd2 = ContentDisposition {
-///     disposition: DispositionType::FormData,
-///     parameters: vec![
-///         DispositionParam::Name(String::from("file")),
-///         DispositionParam::Filename(String::from("bill.odt")),
-///     ],
-/// };
-/// assert_eq!(cd2.get_name(), Some("file")); // field name
-/// assert_eq!(cd2.get_filename(), Some("bill.odt"));
-///
-/// // HTTP response header with Unicode characters in file names
-/// let cd3 = ContentDisposition {
-///     disposition: DispositionType::Attachment,
-///     parameters: vec![
-///         DispositionParam::FilenameExt(ExtendedValue {
-///             charset: Charset::Ext(String::from("UTF-8")),
-///             language_tag: None,
-///             value: String::from("\u{1f600}.svg").into_bytes(),
-///         }),
-///         // fallback for better compatibility
-///         DispositionParam::Filename(String::from("Grinning-Face-Emoji.svg"))
-///     ],
-/// };
-/// assert_eq!(cd3.get_filename_ext().map(|ev| ev.value.as_ref()),
-///            Some("\u{1f600}.svg".as_bytes()));
-/// ```
-///
-/// # WARN
-/// If "filename" parameter is supplied, do not use the file name blindly, check and possibly
-/// change to match local file system conventions if applicable, and do not use directory path
-/// information that may be present. See [RFC2183](https://tools.ietf.org/html/rfc2183#section-2.3)
-/// .
-#[derive(Clone, Debug, PartialEq)]
-pub struct ContentDisposition {
-    /// The disposition type
-    pub disposition: DispositionType,
-    /// Disposition parameters
-    pub parameters: Vec<DispositionParam>,
-}
-
-impl ContentDisposition {
-    /// Parse a raw Content-Disposition header value.
-    pub fn from_raw(hv: &header::HeaderValue) -> Result<Self, crate::error::ParseError> {
-        // `header::from_one_raw_str` invokes `hv.to_str` which assumes `hv` contains only visible
-        //  ASCII characters. So `hv.as_bytes` is necessary here.
-        let hv = String::from_utf8(hv.as_bytes().to_vec())
-            .map_err(|_| crate::error::ParseError::Header)?;
-        let (disp_type, mut left) = split_once_and_trim(hv.as_str().trim(), ';');
-        if disp_type.is_empty() {
-            return Err(crate::error::ParseError::Header);
-        }
-        let mut cd = ContentDisposition {
-            disposition: disp_type.into(),
-            parameters: Vec::new(),
-        };
-
-        while !left.is_empty() {
-            let (param_name, new_left) = split_once_and_trim(left, '=');
-            if param_name.is_empty() || param_name == "*" || new_left.is_empty() {
-                return Err(crate::error::ParseError::Header);
-            }
-            left = new_left;
-            if param_name.ends_with('*') {
-                // extended parameters
-                let param_name = &param_name[..param_name.len() - 1]; // trim asterisk
-                let (ext_value, new_left) = split_once_and_trim(left, ';');
-                left = new_left;
-                let ext_value = header::parse_extended_value(ext_value)?;
-
-                let param = if param_name.eq_ignore_ascii_case("filename") {
-                    DispositionParam::FilenameExt(ext_value)
-                } else {
-                    DispositionParam::UnknownExt(param_name.to_owned(), ext_value)
-                };
-                cd.parameters.push(param);
-            } else {
-                // regular parameters
-                let value = if left.starts_with('\"') {
-                    // quoted-string: defined in RFC6266 -> RFC2616 Section 3.6
-                    let mut escaping = false;
-                    let mut quoted_string = vec![];
-                    let mut end = None;
-                    // search for closing quote
-                    for (i, &c) in left.as_bytes().iter().skip(1).enumerate() {
-                        if escaping {
-                            escaping = false;
-                            quoted_string.push(c);
-                        } else if c == 0x5c {
-                            // backslash
-                            escaping = true;
-                        } else if c == 0x22 {
-                            // double quote
-                            end = Some(i + 1); // cuz skipped 1 for the leading quote
-                            break;
-                        } else {
-                            quoted_string.push(c);
-                        }
-                    }
-                    left = &left[end.ok_or(crate::error::ParseError::Header)? + 1..];
-                    left = split_once(left, ';').1.trim_start();
-                    // In fact, it should not be Err if the above code is correct.
-                    String::from_utf8(quoted_string)
-                        .map_err(|_| crate::error::ParseError::Header)?
-                } else {
-                    // token: won't contains semicolon according to RFC 2616 Section 2.2
-                    let (token, new_left) = split_once_and_trim(left, ';');
-                    left = new_left;
-                    if token.is_empty() {
-                        // quoted-string can be empty, but token cannot be empty
-                        return Err(crate::error::ParseError::Header);
-                    }
-                    token.to_owned()
-                };
-
-                let param = if param_name.eq_ignore_ascii_case("name") {
-                    DispositionParam::Name(value)
-                } else if param_name.eq_ignore_ascii_case("filename") {
-                    // See also comments in test_from_raw_uncessary_percent_decode.
-                    DispositionParam::Filename(value)
-                } else {
-                    DispositionParam::Unknown(param_name.to_owned(), value)
-                };
-                cd.parameters.push(param);
-            }
-        }
-
-        Ok(cd)
-    }
-
-    /// Returns `true` if it is [`Inline`](DispositionType::Inline).
-    pub fn is_inline(&self) -> bool {
-        match self.disposition {
-            DispositionType::Inline => true,
-            _ => false,
-        }
-    }
-
-    /// Returns `true` if it is [`Attachment`](DispositionType::Attachment).
-    pub fn is_attachment(&self) -> bool {
-        match self.disposition {
-            DispositionType::Attachment => true,
-            _ => false,
-        }
-    }
-
-    /// Returns `true` if it is [`FormData`](DispositionType::FormData).
-    pub fn is_form_data(&self) -> bool {
-        match self.disposition {
-            DispositionType::FormData => true,
-            _ => false,
-        }
-    }
-
-    /// Returns `true` if it is [`Ext`](DispositionType::Ext) and the `disp_type` matches.
-    pub fn is_ext<T: AsRef<str>>(&self, disp_type: T) -> bool {
-        match self.disposition {
-            DispositionType::Ext(ref t)
-                if t.eq_ignore_ascii_case(disp_type.as_ref()) =>
-            {
-                true
-            }
-            _ => false,
-        }
-    }
-
-    /// Return the value of *name* if exists.
-    pub fn get_name(&self) -> Option<&str> {
-        self.parameters.iter().filter_map(|p| p.as_name()).nth(0)
-    }
-
-    /// Return the value of *filename* if exists.
-    pub fn get_filename(&self) -> Option<&str> {
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_filename())
-            .nth(0)
-    }
-
-    /// Return the value of *filename\** if exists.
-    pub fn get_filename_ext(&self) -> Option<&ExtendedValue> {
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_filename_ext())
-            .nth(0)
-    }
-
-    /// Return the value of the parameter which the `name` matches.
-    pub fn get_unknown<T: AsRef<str>>(&self, name: T) -> Option<&str> {
-        let name = name.as_ref();
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_unknown(name))
-            .nth(0)
-    }
-
-    /// Return the value of the extended parameter which the `name` matches.
-    pub fn get_unknown_ext<T: AsRef<str>>(&self, name: T) -> Option<&ExtendedValue> {
-        let name = name.as_ref();
-        self.parameters
-            .iter()
-            .filter_map(|p| p.as_unknown_ext(name))
-            .nth(0)
-    }
-}
-
-impl IntoHeaderValue for ContentDisposition {
-    type Error = header::InvalidHeaderValueBytes;
-
-    fn try_into(self) -> Result<header::HeaderValue, Self::Error> {
-        let mut writer = Writer::new();
-        let _ = write!(&mut writer, "{}", self);
-        header::HeaderValue::from_shared(writer.take())
-    }
-}
-
-impl Header for ContentDisposition {
-    fn name() -> header::HeaderName {
-        header::CONTENT_DISPOSITION
-    }
-
-    fn parse<T: crate::HttpMessage>(msg: &T) -> Result<Self, crate::error::ParseError> {
-        if let Some(h) = msg.headers().get(&Self::name()) {
-            Self::from_raw(&h)
-        } else {
-            Err(crate::error::ParseError::Header)
-        }
-    }
-}
-
-impl fmt::Display for DispositionType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            DispositionType::Inline => write!(f, "inline"),
-            DispositionType::Attachment => write!(f, "attachment"),
-            DispositionType::FormData => write!(f, "form-data"),
-            DispositionType::Ext(ref s) => write!(f, "{}", s),
-        }
-    }
-}
-
-impl fmt::Display for DispositionParam {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // All ASCII control characters (0-30, 127) including horizontal tab, double quote, and
-        // backslash should be escaped in quoted-string (i.e. "foobar").
-        // Ref: RFC6266 S4.1 -> RFC2616 S3.6
-        // filename-parm  = "filename" "=" value
-        // value          = token | quoted-string
-        // quoted-string  = ( <"> *(qdtext | quoted-pair ) <"> )
-        // qdtext         = <any TEXT except <">>
-        // quoted-pair    = "\" CHAR
-        // TEXT           = <any OCTET except CTLs,
-        //                  but including LWS>
-        // LWS            = [CRLF] 1*( SP | HT )
-        // OCTET          = <any 8-bit sequence of data>
-        // CHAR           = <any US-ASCII character (octets 0 - 127)>
-        // CTL            = <any US-ASCII control character
-        //                  (octets 0 - 31) and DEL (127)>
-        //
-        // Ref: RFC7578 S4.2 -> RFC2183 S2 -> RFC2045 S5.1
-        // parameter := attribute "=" value
-        // attribute := token
-        //              ; Matching of attributes
-        //              ; is ALWAYS case-insensitive.
-        // value := token / quoted-string
-        // token := 1*<any (US-ASCII) CHAR except SPACE, CTLs,
-        //             or tspecials>
-        // tspecials :=  "(" / ")" / "<" / ">" / "@" /
-        //               "," / ";" / ":" / "\" / <">
-        //               "/" / "[" / "]" / "?" / "="
-        //               ; Must be in quoted-string,
-        //               ; to use within parameter values
-        //
-        //
-        // See also comments in test_from_raw_uncessary_percent_decode.
-        lazy_static! {
-            static ref RE: Regex = Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap();
-        }
-        match self {
-            DispositionParam::Name(ref value) => write!(f, "name={}", value),
-            DispositionParam::Filename(ref value) => {
-                write!(f, "filename=\"{}\"", RE.replace_all(value, "\\$0").as_ref())
-            }
-            DispositionParam::Unknown(ref name, ref value) => write!(
-                f,
-                "{}=\"{}\"",
-                name,
-                &RE.replace_all(value, "\\$0").as_ref()
-            ),
-            DispositionParam::FilenameExt(ref ext_value) => {
-                write!(f, "filename*={}", ext_value)
-            }
-            DispositionParam::UnknownExt(ref name, ref ext_value) => {
-                write!(f, "{}*={}", name, ext_value)
-            }
-        }
-    }
-}
-
-impl fmt::Display for ContentDisposition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.disposition)?;
-        self.parameters
-            .iter()
-            .map(|param| write!(f, "; {}", param))
-            .collect()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{ContentDisposition, DispositionParam, DispositionType};
-    use crate::header::shared::Charset;
-    use crate::header::{ExtendedValue, HeaderValue};
-
-    #[test]
-    fn test_from_raw_basic() {
-        assert!(ContentDisposition::from_raw(&HeaderValue::from_static("")).is_err());
-
-        let a = HeaderValue::from_static(
-            "form-data; dummy=3; name=upload; filename=\"sample.png\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static("attachment; filename=\"image.jpg\"");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::Filename("image.jpg".to_owned())],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static("inline; filename=image.jpg");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![DispositionParam::Filename("image.jpg".to_owned())],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static(
-            "attachment; creation-date=\"Wed, 12 Feb 1997 16:29:51 -0500\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::Unknown(
-                String::from("creation-date"),
-                "Wed, 12 Feb 1997 16:29:51 -0500".to_owned(),
-            )],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_extended() {
-        let a = HeaderValue::from_static(
-            "attachment; filename*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::FilenameExt(ExtendedValue {
-                charset: Charset::Ext(String::from("UTF-8")),
-                language_tag: None,
-                value: vec![
-                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20,
-                    b'r', b'a', b't', b'e', b's',
-                ],
-            })],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static(
-            "attachment; filename*=UTF-8''%c2%a3%20and%20%e2%82%ac%20rates",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![DispositionParam::FilenameExt(ExtendedValue {
-                charset: Charset::Ext(String::from("UTF-8")),
-                language_tag: None,
-                value: vec![
-                    0xc2, 0xa3, 0x20, b'a', b'n', b'd', 0x20, 0xe2, 0x82, 0xac, 0x20,
-                    b'r', b'a', b't', b'e', b's',
-                ],
-            })],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_extra_whitespace() {
-        let a = HeaderValue::from_static(
-            "form-data  ; du-mmy= 3  ; name =upload ; filename =  \"sample.png\"  ; ",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("du-mmy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_unordered() {
-        let a = HeaderValue::from_static(
-            "form-data; dummy=3; filename=\"sample.png\" ; name=upload;",
-            // Actually, a trailling semolocon is not compliant. But it is fine to accept.
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_str(
-            "attachment; filename*=iso-8859-1''foo-%E4.html; filename=\"foo-ä.html\"",
-        )
-        .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![
-                DispositionParam::FilenameExt(ExtendedValue {
-                    charset: Charset::Iso_8859_1,
-                    language_tag: None,
-                    value: b"foo-\xe4.html".to_vec(),
-                }),
-                DispositionParam::Filename("foo-ä.html".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_only_disp() {
-        let a = ContentDisposition::from_raw(&HeaderValue::from_static("attachment"))
-            .unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Attachment,
-            parameters: vec![],
-        };
-        assert_eq!(a, b);
-
-        let a =
-            ContentDisposition::from_raw(&HeaderValue::from_static("inline ;")).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![],
-        };
-        assert_eq!(a, b);
-
-        let a = ContentDisposition::from_raw(&HeaderValue::from_static(
-            "unknown-disp-param",
-        ))
-        .unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Ext(String::from("unknown-disp-param")),
-            parameters: vec![],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn from_raw_with_mixed_case() {
-        let a = HeaderValue::from_str(
-            "InLInE; fIlenAME*=iso-8859-1''foo-%E4.html; filEName=\"foo-ä.html\"",
-        )
-        .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![
-                DispositionParam::FilenameExt(ExtendedValue {
-                    charset: Charset::Iso_8859_1,
-                    language_tag: None,
-                    value: b"foo-\xe4.html".to_vec(),
-                }),
-                DispositionParam::Filename("foo-ä.html".to_owned()),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn from_raw_with_unicode() {
-        /* RFC7578 Section 4.2:
-        Some commonly deployed systems use multipart/form-data with file names directly encoded
-        including octets outside the US-ASCII range. The encoding used for the file names is
-        typically UTF-8, although HTML forms will use the charset associated with the form.
-
-        Mainstream browsers like Firefox (gecko) and Chrome use UTF-8 directly as above.
-        (And now, only UTF-8 is handled by this implementation.)
-        */
-        let a =
-            HeaderValue::from_str("form-data; name=upload; filename=\"文件.webp\"")
-                .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name(String::from("upload")),
-                DispositionParam::Filename(String::from("文件.webp")),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_str(
-            "form-data; name=upload; filename=\"余固知謇謇之為患兮，忍而不能舍也.pptx\"",
-        )
-        .unwrap();
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name(String::from("upload")),
-                DispositionParam::Filename(String::from(
-                    "余固知謇謇之為患兮，忍而不能舍也.pptx",
-                )),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_escape() {
-        let a = HeaderValue::from_static(
-            "form-data; dummy=3; name=upload; filename=\"s\\amp\\\"le.png\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename(
-                    ['s', 'a', 'm', 'p', '\"', 'l', 'e', '.', 'p', 'n', 'g']
-                        .iter()
-                        .collect(),
-                ),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_semicolon() {
-        let a =
-            HeaderValue::from_static("form-data; filename=\"A semicolon here;.pdf\"");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![DispositionParam::Filename(String::from(
-                "A semicolon here;.pdf",
-            ))],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_uncessary_percent_decode() {
-        // In fact, RFC7578 (multipart/form-data) Section 2 and 4.2 suggests that filename with
-        // non-ASCII characters MAY be percent-encoded.
-        // On the contrary, RFC6266 or other RFCs related to Content-Disposition response header
-        // do not mention such percent-encoding.
-        // So, it appears to be undecidable whether to percent-decode or not without
-        // knowing the usage scenario (multipart/form-data v.s. HTTP response header) and
-        // inevitable to unnecessarily percent-decode filename with %XX in the former scenario.
-        // Fortunately, it seems that almost all mainstream browsers just send UTF-8 encoded file
-        // names in quoted-string format (tested on Edge, IE11, Chrome and Firefox) without
-        // percent-encoding. So we do not bother to attempt to percent-decode.
-        let a = HeaderValue::from_static(
-            "form-data; name=photo; filename=\"%74%65%73%74%2e%70%6e%67\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name("photo".to_owned()),
-                DispositionParam::Filename(String::from("%74%65%73%74%2e%70%6e%67")),
-            ],
-        };
-        assert_eq!(a, b);
-
-        let a = HeaderValue::from_static(
-            "form-data; name=photo; filename=\"%74%65%73%74.png\"",
-        );
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let b = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Name("photo".to_owned()),
-                DispositionParam::Filename(String::from("%74%65%73%74.png")),
-            ],
-        };
-        assert_eq!(a, b);
-    }
-
-    #[test]
-    fn test_from_raw_param_value_missing() {
-        let a = HeaderValue::from_static("form-data; name=upload ; filename=");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("attachment; dummy=; filename=invoice.pdf");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; filename=  ");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; filename=\"\"");
-        assert!(ContentDisposition::from_raw(&a).expect("parse cd").get_filename().expect("filename").is_empty());
-    }
-
-    #[test]
-    fn test_from_raw_param_name_missing() {
-        let a = HeaderValue::from_static("inline; =\"test.txt\"");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; =diary.odt");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-
-        let a = HeaderValue::from_static("inline; =");
-        assert!(ContentDisposition::from_raw(&a).is_err());
-    }
-
-    #[test]
-    fn test_display_extended() {
-        let as_string =
-            "attachment; filename*=UTF-8'en'%C2%A3%20and%20%E2%82%AC%20rates";
-        let a = HeaderValue::from_static(as_string);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(as_string, display_rendered);
-
-        let a = HeaderValue::from_static("attachment; filename=colourful.csv");
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(
-            "attachment; filename=\"colourful.csv\"".to_owned(),
-            display_rendered
-        );
-    }
-
-    #[test]
-    fn test_display_quote() {
-        let as_string = "form-data; name=upload; filename=\"Quote\\\"here.png\"";
-        as_string
-            .find(['\\', '\"'].iter().collect::<String>().as_str())
-            .unwrap(); // ensure `\"` is there
-        let a = HeaderValue::from_static(as_string);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(as_string, display_rendered);
-    }
-
-    #[test]
-    fn test_display_space_tab() {
-        let as_string = "form-data; name=upload; filename=\"Space here.png\"";
-        let a = HeaderValue::from_static(as_string);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(as_string, display_rendered);
-
-        let a: ContentDisposition = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![DispositionParam::Filename(String::from("Tab\there.png"))],
-        };
-        let display_rendered = format!("{}", a);
-        assert_eq!("inline; filename=\"Tab\x09here.png\"", display_rendered);
-    }
-
-    #[test]
-    fn test_display_control_characters() {
-        /* let a = "attachment; filename=\"carriage\rreturn.png\"";
-        let a = HeaderValue::from_static(a);
-        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
-        let display_rendered = format!("{}", a);
-        assert_eq!(
-            "attachment; filename=\"carriage\\\rreturn.png\"",
-            display_rendered
-        );*/
-        // No way to create a HeaderValue containing a carriage return.
-
-        let a: ContentDisposition = ContentDisposition {
-            disposition: DispositionType::Inline,
-            parameters: vec![DispositionParam::Filename(String::from("bell\x07.png"))],
-        };
-        let display_rendered = format!("{}", a);
-        assert_eq!("inline; filename=\"bell\\\x07.png\"", display_rendered);
-    }
-
-    #[test]
-    fn test_param_methods() {
-        let param = DispositionParam::Filename(String::from("sample.txt"));
-        assert!(param.is_filename());
-        assert_eq!(param.as_filename().unwrap(), "sample.txt");
-
-        let param = DispositionParam::Unknown(String::from("foo"), String::from("bar"));
-        assert!(param.is_unknown("foo"));
-        assert_eq!(param.as_unknown("fOo"), Some("bar"));
-    }
-
-    #[test]
-    fn test_disposition_methods() {
-        let cd = ContentDisposition {
-            disposition: DispositionType::FormData,
-            parameters: vec![
-                DispositionParam::Unknown("dummy".to_owned(), "3".to_owned()),
-                DispositionParam::Name("upload".to_owned()),
-                DispositionParam::Filename("sample.png".to_owned()),
-            ],
-        };
-        assert_eq!(cd.get_name(), Some("upload"));
-        assert_eq!(cd.get_unknown("dummy"), Some("3"));
-        assert_eq!(cd.get_filename(), Some("sample.png"));
-        assert_eq!(cd.get_unknown_ext("dummy"), None);
-        assert_eq!(cd.get_unknown("duMMy"), Some("3"));
-    }
-}
--- a/actix-http/src/header/map.rs
+++ b/actix-http/src/header/map.rs
@@ -1,384 +0,0 @@
-use either::Either;
-use hashbrown::hash_map::{self, Entry};
-use hashbrown::HashMap;
-use http::header::{HeaderName, HeaderValue};
-use http::HttpTryFrom;
-
-/// A set of HTTP headers
-///
-/// `HeaderMap` is an multimap of [`HeaderName`] to values.
-///
-/// [`HeaderName`]: struct.HeaderName.html
-#[derive(Debug, Clone)]
-pub struct HeaderMap {
-    pub(crate) inner: HashMap<HeaderName, Value>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum Value {
-    One(HeaderValue),
-    Multi(Vec<HeaderValue>),
-}
-
-impl Value {
-    fn get(&self) -> &HeaderValue {
-        match self {
-            Value::One(ref val) => val,
-            Value::Multi(ref val) => &val[0],
-        }
-    }
-
-    fn get_mut(&mut self) -> &mut HeaderValue {
-        match self {
-            Value::One(ref mut val) => val,
-            Value::Multi(ref mut val) => &mut val[0],
-        }
-    }
-
-    fn append(&mut self, val: HeaderValue) {
-        match self {
-            Value::One(_) => {
-                let data = std::mem::replace(self, Value::Multi(vec![val]));
-                match data {
-                    Value::One(val) => self.append(val),
-                    Value::Multi(_) => unreachable!(),
-                }
-            }
-            Value::Multi(ref mut vec) => vec.push(val),
-        }
-    }
-}
-
-impl HeaderMap {
-    /// Create an empty `HeaderMap`.
-    ///
-    /// The map will be created without any capacity. This function will not
-    /// allocate.
-    pub fn new() -> Self {
-        HeaderMap {
-            inner: HashMap::new(),
-        }
-    }
-
-    /// Create an empty `HeaderMap` with the specified capacity.
-    ///
-    /// The returned map will allocate internal storage in order to hold about
-    /// `capacity` elements without reallocating. However, this is a "best
-    /// effort" as there are usage patterns that could cause additional
-    /// allocations before `capacity` headers are stored in the map.
-    ///
-    /// More capacity than requested may be allocated.
-    pub fn with_capacity(capacity: usize) -> HeaderMap {
-        HeaderMap {
-            inner: HashMap::with_capacity(capacity),
-        }
-    }
-
-    /// Returns the number of keys stored in the map.
-    ///
-    /// This number could be be less than or equal to actual headers stored in
-    /// the map.
-    pub fn len(&self) -> usize {
-        self.inner.len()
-    }
-
-    /// Returns true if the map contains no elements.
-    pub fn is_empty(&self) -> bool {
-        self.inner.len() == 0
-    }
-
-    /// Clears the map, removing all key-value pairs. Keeps the allocated memory
-    /// for reuse.
-    pub fn clear(&mut self) {
-        self.inner.clear();
-    }
-
-    /// Returns the number of headers the map can hold without reallocating.
-    ///
-    /// This number is an approximation as certain usage patterns could cause
-    /// additional allocations before the returned capacity is filled.
-    pub fn capacity(&self) -> usize {
-        self.inner.capacity()
-    }
-
-    /// Reserves capacity for at least `additional` more headers to be inserted
-    /// into the `HeaderMap`.
-    ///
-    /// The header map may reserve more space to avoid frequent reallocations.
-    /// Like with `with_capacity`, this will be a "best effort" to avoid
-    /// allocations until `additional` more headers are inserted. Certain usage
-    /// patterns could cause additional allocations before the number is
-    /// reached.
-    pub fn reserve(&mut self, additional: usize) {
-        self.inner.reserve(additional)
-    }
-
-    /// Returns a reference to the value associated with the key.
-    ///
-    /// If there are multiple values associated with the key, then the first one
-    /// is returned. Use `get_all` to get all values associated with a given
-    /// key. Returns `None` if there are no values associated with the key.
-    pub fn get<N: AsName>(&self, name: N) -> Option<&HeaderValue> {
-        self.get2(name).map(|v| v.get())
-    }
-
-    fn get2<N: AsName>(&self, name: N) -> Option<&Value> {
-        match name.as_name() {
-            Either::Left(name) => self.inner.get(name),
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    self.inner.get(&name)
-                } else {
-                    None
-                }
-            }
-        }
-    }
-
-    /// Returns a view of all values associated with a key.
-    ///
-    /// The returned view does not incur any allocations and allows iterating
-    /// the values associated with the key.  See [`GetAll`] for more details.
-    /// Returns `None` if there are no values associated with the key.
-    ///
-    /// [`GetAll`]: struct.GetAll.html
-    pub fn get_all<N: AsName>(&self, name: N) -> GetAll {
-        GetAll {
-            idx: 0,
-            item: self.get2(name),
-        }
-    }
-
-    /// Returns a mutable reference to the value associated with the key.
-    ///
-    /// If there are multiple values associated with the key, then the first one
-    /// is returned. Use `entry` to get all values associated with a given
-    /// key. Returns `None` if there are no values associated with the key.
-    pub fn get_mut<N: AsName>(&mut self, name: N) -> Option<&mut HeaderValue> {
-        match name.as_name() {
-            Either::Left(name) => self.inner.get_mut(name).map(|v| v.get_mut()),
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    self.inner.get_mut(&name).map(|v| v.get_mut())
-                } else {
-                    None
-                }
-            }
-        }
-    }
-
-    /// Returns true if the map contains a value for the specified key.
-    pub fn contains_key<N: AsName>(&self, key: N) -> bool {
-        match key.as_name() {
-            Either::Left(name) => self.inner.contains_key(name),
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    self.inner.contains_key(&name)
-                } else {
-                    false
-                }
-            }
-        }
-    }
-
-    /// An iterator visiting all key-value pairs.
-    ///
-    /// The iteration order is arbitrary, but consistent across platforms for
-    /// the same crate version. Each key will be yielded once per associated
-    /// value. So, if a key has 3 associated values, it will be yielded 3 times.
-    pub fn iter(&self) -> Iter {
-        Iter::new(self.inner.iter())
-    }
-
-    /// An iterator visiting all keys.
-    ///
-    /// The iteration order is arbitrary, but consistent across platforms for
-    /// the same crate version. Each key will be yielded only once even if it
-    /// has multiple associated values.
-    pub fn keys(&self) -> Keys {
-        Keys(self.inner.keys())
-    }
-
-    /// Inserts a key-value pair into the map.
-    ///
-    /// If the map did not previously have this key present, then `None` is
-    /// returned.
-    ///
-    /// If the map did have this key present, the new value is associated with
-    /// the key and all previous values are removed. **Note** that only a single
-    /// one of the previous values is returned. If there are multiple values
-    /// that have been previously associated with the key, then the first one is
-    /// returned. See `insert_mult` on `OccupiedEntry` for an API that returns
-    /// all values.
-    ///
-    /// The key is not updated, though; this matters for types that can be `==`
-    /// without being identical.
-    pub fn insert(&mut self, key: HeaderName, val: HeaderValue) {
-        let _ = self.inner.insert(key, Value::One(val));
-    }
-
-    /// Inserts a key-value pair into the map.
-    ///
-    /// If the map did not previously have this key present, then `false` is
-    /// returned.
-    ///
-    /// If the map did have this key present, the new value is pushed to the end
-    /// of the list of values currently associated with the key. The key is not
-    /// updated, though; this matters for types that can be `==` without being
-    /// identical.
-    pub fn append(&mut self, key: HeaderName, value: HeaderValue) {
-        match self.inner.entry(key) {
-            Entry::Occupied(mut entry) => entry.get_mut().append(value),
-            Entry::Vacant(entry) => {
-                entry.insert(Value::One(value));
-            }
-        }
-    }
-
-    /// Removes all headers for a particular header name from the map.
-    pub fn remove<N: AsName>(&mut self, key: N) {
-        match key.as_name() {
-            Either::Left(name) => {
-                let _ = self.inner.remove(name);
-            }
-            Either::Right(s) => {
-                if let Ok(name) = HeaderName::try_from(s) {
-                    let _ = self.inner.remove(&name);
-                }
-            }
-        }
-    }
-}
-
-#[doc(hidden)]
-pub trait AsName {
-    fn as_name(&self) -> Either<&HeaderName, &str>;
-}
-
-impl AsName for HeaderName {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Left(self)
-    }
-}
-
-impl<'a> AsName for &'a HeaderName {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Left(self)
-    }
-}
-
-impl<'a> AsName for &'a str {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Right(self)
-    }
-}
-
-impl AsName for String {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Right(self.as_str())
-    }
-}
-
-impl<'a> AsName for &'a String {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
-        Either::Right(self.as_str())
-    }
-}
-
-pub struct GetAll<'a> {
-    idx: usize,
-    item: Option<&'a Value>,
-}
-
-impl<'a> Iterator for GetAll<'a> {
-    type Item = &'a HeaderValue;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a HeaderValue> {
-        if let Some(ref val) = self.item {
-            match val {
-                Value::One(ref val) => {
-                    self.item.take();
-                    Some(val)
-                }
-                Value::Multi(ref vec) => {
-                    if self.idx < vec.len() {
-                        let item = Some(&vec[self.idx]);
-                        self.idx += 1;
-                        item
-                    } else {
-                        self.item.take();
-                        None
-                    }
-                }
-            }
-        } else {
-            None
-        }
-    }
-}
-
-pub struct Keys<'a>(hash_map::Keys<'a, HeaderName, Value>);
-
-impl<'a> Iterator for Keys<'a> {
-    type Item = &'a HeaderName;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a HeaderName> {
-        self.0.next()
-    }
-}
-
-impl<'a> IntoIterator for &'a HeaderMap {
-    type Item = (&'a HeaderName, &'a HeaderValue);
-    type IntoIter = Iter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-pub struct Iter<'a> {
-    idx: usize,
-    current: Option<(&'a HeaderName, &'a Vec<HeaderValue>)>,
-    iter: hash_map::Iter<'a, HeaderName, Value>,
-}
-
-impl<'a> Iter<'a> {
-    fn new(iter: hash_map::Iter<'a, HeaderName, Value>) -> Self {
-        Self {
-            iter,
-            idx: 0,
-            current: None,
-        }
-    }
-}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = (&'a HeaderName, &'a HeaderValue);
-
-    #[inline]
-    fn next(&mut self) -> Option<(&'a HeaderName, &'a HeaderValue)> {
-        if let Some(ref mut item) = self.current {
-            if self.idx < item.1.len() {
-                let item = (item.0, &item.1[self.idx]);
-                self.idx += 1;
-                return Some(item);
-            } else {
-                self.idx = 0;
-                self.current.take();
-            }
-        }
-        if let Some(item) = self.iter.next() {
-            match item.1 {
-                Value::One(ref value) => Some((item.0, value)),
-                Value::Multi(ref vec) => {
-                    self.current = Some((item.0, vec));
-                    self.next()
-                }
-            }
-        } else {
-            None
-        }
-    }
-}
--- a/actix-http/src/header/mod.rs
+++ b/actix-http/src/header/mod.rs
@@ -1,504 +0,0 @@
-//! Various http headers
-// This is mostly copy of [hyper](https://github.com/hyperium/hyper/tree/master/src/header)
-
-use std::{fmt, str::FromStr};
-
-use bytes::{Bytes, BytesMut};
-use http::Error as HttpError;
-use mime::Mime;
-use percent_encoding::{AsciiSet, CONTROLS};
-
-pub use http::header::*;
-
-use crate::error::ParseError;
-use crate::httpmessage::HttpMessage;
-
-mod common;
-pub(crate) mod map;
-mod shared;
-pub use self::common::*;
-#[doc(hidden)]
-pub use self::shared::*;
-
-#[doc(hidden)]
-pub use self::map::GetAll;
-pub use self::map::HeaderMap;
-
-/// A trait for any object that will represent a header field and value.
-pub trait Header
-where
-    Self: IntoHeaderValue,
-{
-    /// Returns the name of the header field
-    fn name() -> HeaderName;
-
-    /// Parse a header
-    fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError>;
-}
-
-/// A trait for any object that can be Converted to a `HeaderValue`
-pub trait IntoHeaderValue: Sized {
-    /// The type returned in the event of a conversion error.
-    type Error: Into<HttpError>;
-
-    /// Try to convert value to a Header value.
-    fn try_into(self) -> Result<HeaderValue, Self::Error>;
-}
-
-impl IntoHeaderValue for HeaderValue {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        Ok(self)
-    }
-}
-
-impl<'a> IntoHeaderValue for &'a str {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        self.parse()
-    }
-}
-
-impl<'a> IntoHeaderValue for &'a [u8] {
-    type Error = InvalidHeaderValue;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_bytes(self)
-    }
-}
-
-impl IntoHeaderValue for Bytes {
-    type Error = InvalidHeaderValueBytes;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_shared(self)
-    }
-}
-
-impl IntoHeaderValue for Vec<u8> {
-    type Error = InvalidHeaderValueBytes;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_shared(Bytes::from(self))
-    }
-}
-
-impl IntoHeaderValue for String {
-    type Error = InvalidHeaderValueBytes;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_shared(Bytes::from(self))
-    }
-}
-
-impl IntoHeaderValue for usize {
-    type Error = InvalidHeaderValueBytes;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        let s = format!("{}", self);
-        HeaderValue::from_shared(Bytes::from(s))
-    }
-}
-
-impl IntoHeaderValue for u64 {
-    type Error = InvalidHeaderValueBytes;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        let s = format!("{}", self);
-        HeaderValue::from_shared(Bytes::from(s))
-    }
-}
-
-impl IntoHeaderValue for Mime {
-    type Error = InvalidHeaderValueBytes;
-
-    #[inline]
-    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_shared(Bytes::from(format!("{}", self)))
-    }
-}
-
-/// Represents supported types of content encodings
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum ContentEncoding {
-    /// Automatically select encoding based on encoding negotiation
-    Auto,
-    /// A format using the Brotli algorithm
-    Br,
-    /// A format using the zlib structure with deflate algorithm
-    Deflate,
-    /// Gzip algorithm
-    Gzip,
-    /// Indicates the identity function (i.e. no compression, nor modification)
-    Identity,
-}
-
-impl ContentEncoding {
-    #[inline]
-    /// Is the content compressed?
-    pub fn is_compression(self) -> bool {
-        match self {
-            ContentEncoding::Identity | ContentEncoding::Auto => false,
-            _ => true,
-        }
-    }
-
-    #[inline]
-    /// Convert content encoding to string
-    pub fn as_str(self) -> &'static str {
-        match self {
-            ContentEncoding::Br => "br",
-            ContentEncoding::Gzip => "gzip",
-            ContentEncoding::Deflate => "deflate",
-            ContentEncoding::Identity | ContentEncoding::Auto => "identity",
-        }
-    }
-
-    #[inline]
-    /// default quality value
-    pub fn quality(self) -> f64 {
-        match self {
-            ContentEncoding::Br => 1.1,
-            ContentEncoding::Gzip => 1.0,
-            ContentEncoding::Deflate => 0.9,
-            ContentEncoding::Identity | ContentEncoding::Auto => 0.1,
-        }
-    }
-}
-
-impl<'a> From<&'a str> for ContentEncoding {
-    fn from(s: &'a str) -> ContentEncoding {
-        let s = s.trim();
-
-        if s.eq_ignore_ascii_case("br") {
-            ContentEncoding::Br
-        } else if s.eq_ignore_ascii_case("gzip") {
-            ContentEncoding::Gzip
-        } else if s.eq_ignore_ascii_case("deflate") {
-            ContentEncoding::Deflate
-        } else {
-            ContentEncoding::Identity
-        }
-    }
-}
-
-#[doc(hidden)]
-pub(crate) struct Writer {
-    buf: BytesMut,
-}
-
-impl Writer {
-    fn new() -> Writer {
-        Writer {
-            buf: BytesMut::new(),
-        }
-    }
-    fn take(&mut self) -> Bytes {
-        self.buf.take().freeze()
-    }
-}
-
-impl fmt::Write for Writer {
-    #[inline]
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.buf.extend_from_slice(s.as_bytes());
-        Ok(())
-    }
-
-    #[inline]
-    fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
-        fmt::write(self, args)
-    }
-}
-
-#[inline]
-#[doc(hidden)]
-/// Reads a comma-delimited raw header into a Vec.
-pub fn from_comma_delimited<'a, I: Iterator<Item = &'a HeaderValue> + 'a, T: FromStr>(
-    all: I,
-) -> Result<Vec<T>, ParseError> {
-    let mut result = Vec::new();
-    for h in all {
-        let s = h.to_str().map_err(|_| ParseError::Header)?;
-        result.extend(
-            s.split(',')
-                .filter_map(|x| match x.trim() {
-                    "" => None,
-                    y => Some(y),
-                })
-                .filter_map(|x| x.trim().parse().ok()),
-        )
-    }
-    Ok(result)
-}
-
-#[inline]
-#[doc(hidden)]
-/// Reads a single string when parsing a header.
-pub fn from_one_raw_str<T: FromStr>(val: Option<&HeaderValue>) -> Result<T, ParseError> {
-    if let Some(line) = val {
-        let line = line.to_str().map_err(|_| ParseError::Header)?;
-        if !line.is_empty() {
-            return T::from_str(line).or(Err(ParseError::Header));
-        }
-    }
-    Err(ParseError::Header)
-}
-
-#[inline]
-#[doc(hidden)]
-/// Format an array into a comma-delimited string.
-pub fn fmt_comma_delimited<T>(f: &mut fmt::Formatter, parts: &[T]) -> fmt::Result
-where
-    T: fmt::Display,
-{
-    let mut iter = parts.iter();
-    if let Some(part) = iter.next() {
-        fmt::Display::fmt(part, f)?;
-    }
-    for part in iter {
-        f.write_str(", ")?;
-        fmt::Display::fmt(part, f)?;
-    }
-    Ok(())
-}
-
-// From hyper v0.11.27 src/header/parsing.rs
-
-/// The value part of an extended parameter consisting of three parts:
-/// the REQUIRED character set name (`charset`), the OPTIONAL language information (`language_tag`),
-/// and a character sequence representing the actual value (`value`), separated by single quote
-/// characters. It is defined in [RFC 5987](https://tools.ietf.org/html/rfc5987#section-3.2).
-#[derive(Clone, Debug, PartialEq)]
-pub struct ExtendedValue {
-    /// The character set that is used to encode the `value` to a string.
-    pub charset: Charset,
-    /// The human language details of the `value`, if available.
-    pub language_tag: Option<LanguageTag>,
-    /// The parameter value, as expressed in octets.
-    pub value: Vec<u8>,
-}
-
-/// Parses extended header parameter values (`ext-value`), as defined in
-/// [RFC 5987](https://tools.ietf.org/html/rfc5987#section-3.2).
-///
-/// Extended values are denoted by parameter names that end with `*`.
-///
-/// ## ABNF
-///
-/// ```text
-/// ext-value     = charset  "'" [ language ] "'" value-chars
-///               ; like RFC 2231's <extended-initial-value>
-///               ; (see [RFC2231], Section 7)
-///
-/// charset       = "UTF-8" / "ISO-8859-1" / mime-charset
-///
-/// mime-charset  = 1*mime-charsetc
-/// mime-charsetc = ALPHA / DIGIT
-///               / "!" / "#" / "$" / "%" / "&"
-///               / "+" / "-" / "^" / "_" / "`"
-///               / "{" / "}" / "~"
-///               ; as <mime-charset> in Section 2.3 of [RFC2978]
-///               ; except that the single quote is not included
-///               ; SHOULD be registered in the IANA charset registry
-///
-/// language      = <Language-Tag, defined in [RFC5646], Section 2.1>
-///
-/// value-chars   = *( pct-encoded / attr-char )
-///
-/// pct-encoded   = "%" HEXDIG HEXDIG
-///               ; see [RFC3986], Section 2.1
-///
-/// attr-char     = ALPHA / DIGIT
-///               / "!" / "#" / "$" / "&" / "+" / "-" / "."
-///               / "^" / "_" / "`" / "|" / "~"
-///               ; token except ( "*" / "'" / "%" )
-/// ```
-pub fn parse_extended_value(
-    val: &str,
-) -> Result<ExtendedValue, crate::error::ParseError> {
-    // Break into three pieces separated by the single-quote character
-    let mut parts = val.splitn(3, '\'');
-
-    // Interpret the first piece as a Charset
-    let charset: Charset = match parts.next() {
-        None => return Err(crate::error::ParseError::Header),
-        Some(n) => FromStr::from_str(n).map_err(|_| crate::error::ParseError::Header)?,
-    };
-
-    // Interpret the second piece as a language tag
-    let language_tag: Option<LanguageTag> = match parts.next() {
-        None => return Err(crate::error::ParseError::Header),
-        Some("") => None,
-        Some(s) => match s.parse() {
-            Ok(lt) => Some(lt),
-            Err(_) => return Err(crate::error::ParseError::Header),
-        },
-    };
-
-    // Interpret the third piece as a sequence of value characters
-    let value: Vec<u8> = match parts.next() {
-        None => return Err(crate::error::ParseError::Header),
-        Some(v) => percent_encoding::percent_decode(v.as_bytes()).collect(),
-    };
-
-    Ok(ExtendedValue {
-        value,
-        charset,
-        language_tag,
-    })
-}
-
-impl fmt::Display for ExtendedValue {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let encoded_value =
-            percent_encoding::percent_encode(&self.value[..], HTTP_VALUE);
-        if let Some(ref lang) = self.language_tag {
-            write!(f, "{}'{}'{}", self.charset, lang, encoded_value)
-        } else {
-            write!(f, "{}''{}", self.charset, encoded_value)
-        }
-    }
-}
-
-/// Percent encode a sequence of bytes with a character set defined in
-/// [https://tools.ietf.org/html/rfc5987#section-3.2][url]
-///
-/// [url]: https://tools.ietf.org/html/rfc5987#section-3.2
-pub fn http_percent_encode(f: &mut fmt::Formatter, bytes: &[u8]) -> fmt::Result {
-    let encoded = percent_encoding::percent_encode(bytes, HTTP_VALUE);
-    fmt::Display::fmt(&encoded, f)
-}
-
-/// Convert http::HeaderMap to a HeaderMap
-impl From<http::HeaderMap> for HeaderMap {
-    fn from(map: http::HeaderMap) -> HeaderMap {
-        let mut new_map = HeaderMap::with_capacity(map.capacity());
-        for (h, v) in map.iter() {
-            new_map.append(h.clone(), v.clone());
-        }
-        new_map
-    }
-}
-
-// This encode set is used for HTTP header values and is defined at
-// https://tools.ietf.org/html/rfc5987#section-3.2
-pub(crate) const HTTP_VALUE: &AsciiSet = &CONTROLS
-    .add(b' ')
-    .add(b'"')
-    .add(b'%')
-    .add(b'\'')
-    .add(b'(')
-    .add(b')')
-    .add(b'*')
-    .add(b',')
-    .add(b'/')
-    .add(b':')
-    .add(b';')
-    .add(b'<')
-    .add(b'-')
-    .add(b'>')
-    .add(b'?')
-    .add(b'[')
-    .add(b'\\')
-    .add(b']')
-    .add(b'{')
-    .add(b'}');
-
-#[cfg(test)]
-mod tests {
-    use super::shared::Charset;
-    use super::{parse_extended_value, ExtendedValue};
-    use language_tags::LanguageTag;
-
-    #[test]
-    fn test_parse_extended_value_with_encoding_and_language_tag() {
-        let expected_language_tag = "en".parse::<LanguageTag>().unwrap();
-        // RFC 5987, Section 3.2.2
-        // Extended notation, using the Unicode character U+00A3 (POUND SIGN)
-        let result = parse_extended_value("iso-8859-1'en'%A3%20rates");
-        assert!(result.is_ok());
-        let extended_value = result.unwrap();
-        assert_eq!(Charset::Iso_8859_1, extended_value.charset);
-        assert!(extended_value.language_tag.is_some());
-        assert_eq!(expected_language_tag, extended_value.language_tag.unwrap());
-        assert_eq!(
-            vec![163, b' ', b'r', b'a', b't', b'e', b's'],
-            extended_value.value
-        );
-    }
-
-    #[test]
-    fn test_parse_extended_value_with_encoding() {
-        // RFC 5987, Section 3.2.2
-        // Extended notation, using the Unicode characters U+00A3 (POUND SIGN)
-        // and U+20AC (EURO SIGN)
-        let result = parse_extended_value("UTF-8''%c2%a3%20and%20%e2%82%ac%20rates");
-        assert!(result.is_ok());
-        let extended_value = result.unwrap();
-        assert_eq!(Charset::Ext("UTF-8".to_string()), extended_value.charset);
-        assert!(extended_value.language_tag.is_none());
-        assert_eq!(
-            vec![
-                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a',
-                b't', b'e', b's',
-            ],
-            extended_value.value
-        );
-    }
-
-    #[test]
-    fn test_parse_extended_value_missing_language_tag_and_encoding() {
-        // From: https://greenbytes.de/tech/tc2231/#attwithfn2231quot2
-        let result = parse_extended_value("foo%20bar.html");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_parse_extended_value_partially_formatted() {
-        let result = parse_extended_value("UTF-8'missing third part");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_parse_extended_value_partially_formatted_blank() {
-        let result = parse_extended_value("blank second part'");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_fmt_extended_value_with_encoding_and_language_tag() {
-        let extended_value = ExtendedValue {
-            charset: Charset::Iso_8859_1,
-            language_tag: Some("en".parse().expect("Could not parse language tag")),
-            value: vec![163, b' ', b'r', b'a', b't', b'e', b's'],
-        };
-        assert_eq!("ISO-8859-1'en'%A3%20rates", format!("{}", extended_value));
-    }
-
-    #[test]
-    fn test_fmt_extended_value_with_encoding() {
-        let extended_value = ExtendedValue {
-            charset: Charset::Ext("UTF-8".to_string()),
-            language_tag: None,
-            value: vec![
-                194, 163, b' ', b'a', b'n', b'd', b' ', 226, 130, 172, b' ', b'r', b'a',
-                b't', b'e', b's',
-            ],
-        };
-        assert_eq!(
-            "UTF-8''%C2%A3%20and%20%E2%82%AC%20rates",
-            format!("{}", extended_value)
-        );
-    }
-}
--- a/actix-http/src/httpmessage.rs
+++ b/actix-http/src/httpmessage.rs
@@ -1,261 +0,0 @@
-use std::cell::{Ref, RefMut};
-use std::str;
-
-use encoding_rs::{Encoding, UTF_8};
-use http::header;
-use mime::Mime;
-
-use crate::cookie::Cookie;
-use crate::error::{ContentTypeError, CookieParseError, ParseError};
-use crate::extensions::Extensions;
-use crate::header::{Header, HeaderMap};
-use crate::payload::Payload;
-
-struct Cookies(Vec<Cookie<'static>>);
-
-/// Trait that implements general purpose operations on http messages
-pub trait HttpMessage: Sized {
-    /// Type of message payload stream
-    type Stream;
-
-    /// Read the message headers.
-    fn headers(&self) -> &HeaderMap;
-
-    /// Message payload stream
-    fn take_payload(&mut self) -> Payload<Self::Stream>;
-
-    /// Request's extensions container
-    fn extensions(&self) -> Ref<Extensions>;
-
-    /// Mutable reference to a the request's extensions container
-    fn extensions_mut(&self) -> RefMut<Extensions>;
-
-    #[doc(hidden)]
-    /// Get a header
-    fn get_header<H: Header>(&self) -> Option<H>
-    where
-        Self: Sized,
-    {
-        if self.headers().contains_key(H::name()) {
-            H::parse(self).ok()
-        } else {
-            None
-        }
-    }
-
-    /// Read the request content type. If request does not contain
-    /// *Content-Type* header, empty str get returned.
-    fn content_type(&self) -> &str {
-        if let Some(content_type) = self.headers().get(header::CONTENT_TYPE) {
-            if let Ok(content_type) = content_type.to_str() {
-                return content_type.split(';').next().unwrap().trim();
-            }
-        }
-        ""
-    }
-
-    /// Get content type encoding
-    ///
-    /// UTF-8 is used by default, If request charset is not set.
-    fn encoding(&self) -> Result<&'static Encoding, ContentTypeError> {
-        if let Some(mime_type) = self.mime_type()? {
-            if let Some(charset) = mime_type.get_param("charset") {
-                if let Some(enc) =
-                    Encoding::for_label_no_replacement(charset.as_str().as_bytes())
-                {
-                    Ok(enc)
-                } else {
-                    Err(ContentTypeError::UnknownEncoding)
-                }
-            } else {
-                Ok(UTF_8)
-            }
-        } else {
-            Ok(UTF_8)
-        }
-    }
-
-    /// Convert the request content type to a known mime type.
-    fn mime_type(&self) -> Result<Option<Mime>, ContentTypeError> {
-        if let Some(content_type) = self.headers().get(header::CONTENT_TYPE) {
-            if let Ok(content_type) = content_type.to_str() {
-                return match content_type.parse() {
-                    Ok(mt) => Ok(Some(mt)),
-                    Err(_) => Err(ContentTypeError::ParseError),
-                };
-            } else {
-                return Err(ContentTypeError::ParseError);
-            }
-        }
-        Ok(None)
-    }
-
-    /// Check if request has chunked transfer encoding
-    fn chunked(&self) -> Result<bool, ParseError> {
-        if let Some(encodings) = self.headers().get(header::TRANSFER_ENCODING) {
-            if let Ok(s) = encodings.to_str() {
-                Ok(s.to_lowercase().contains("chunked"))
-            } else {
-                Err(ParseError::Header)
-            }
-        } else {
-            Ok(false)
-        }
-    }
-
-    /// Load request cookies.
-    #[inline]
-    fn cookies(&self) -> Result<Ref<Vec<Cookie<'static>>>, CookieParseError> {
-        if self.extensions().get::<Cookies>().is_none() {
-            let mut cookies = Vec::new();
-            for hdr in self.headers().get_all(header::COOKIE) {
-                let s =
-                    str::from_utf8(hdr.as_bytes()).map_err(CookieParseError::from)?;
-                for cookie_str in s.split(';').map(|s| s.trim()) {
-                    if !cookie_str.is_empty() {
-                        cookies.push(Cookie::parse_encoded(cookie_str)?.into_owned());
-                    }
-                }
-            }
-            self.extensions_mut().insert(Cookies(cookies));
-        }
-        Ok(Ref::map(self.extensions(), |ext| {
-            &ext.get::<Cookies>().unwrap().0
-        }))
-    }
-
-    /// Return request cookie.
-    fn cookie(&self, name: &str) -> Option<Cookie<'static>> {
-        if let Ok(cookies) = self.cookies() {
-            for cookie in cookies.iter() {
-                if cookie.name() == name {
-                    return Some(cookie.to_owned());
-                }
-            }
-        }
-        None
-    }
-}
-
-impl<'a, T> HttpMessage for &'a mut T
-where
-    T: HttpMessage,
-{
-    type Stream = T::Stream;
-
-    fn headers(&self) -> &HeaderMap {
-        (**self).headers()
-    }
-
-    /// Message payload stream
-    fn take_payload(&mut self) -> Payload<Self::Stream> {
-        (**self).take_payload()
-    }
-
-    /// Request's extensions container
-    fn extensions(&self) -> Ref<Extensions> {
-        (**self).extensions()
-    }
-
-    /// Mutable reference to a the request's extensions container
-    fn extensions_mut(&self) -> RefMut<Extensions> {
-        (**self).extensions_mut()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use bytes::Bytes;
-    use encoding_rs::ISO_8859_2;
-    use mime;
-
-    use super::*;
-    use crate::test::TestRequest;
-
-    #[test]
-    fn test_content_type() {
-        let req = TestRequest::with_header("content-type", "text/plain").finish();
-        assert_eq!(req.content_type(), "text/plain");
-        let req =
-            TestRequest::with_header("content-type", "application/json; charset=utf=8")
-                .finish();
-        assert_eq!(req.content_type(), "application/json");
-        let req = TestRequest::default().finish();
-        assert_eq!(req.content_type(), "");
-    }
-
-    #[test]
-    fn test_mime_type() {
-        let req = TestRequest::with_header("content-type", "application/json").finish();
-        assert_eq!(req.mime_type().unwrap(), Some(mime::APPLICATION_JSON));
-        let req = TestRequest::default().finish();
-        assert_eq!(req.mime_type().unwrap(), None);
-        let req =
-            TestRequest::with_header("content-type", "application/json; charset=utf-8")
-                .finish();
-        let mt = req.mime_type().unwrap().unwrap();
-        assert_eq!(mt.get_param(mime::CHARSET), Some(mime::UTF_8));
-        assert_eq!(mt.type_(), mime::APPLICATION);
-        assert_eq!(mt.subtype(), mime::JSON);
-    }
-
-    #[test]
-    fn test_mime_type_error() {
-        let req = TestRequest::with_header(
-            "content-type",
-            "applicationadfadsfasdflknadsfklnadsfjson",
-        )
-        .finish();
-        assert_eq!(Err(ContentTypeError::ParseError), req.mime_type());
-    }
-
-    #[test]
-    fn test_encoding() {
-        let req = TestRequest::default().finish();
-        assert_eq!(UTF_8.name(), req.encoding().unwrap().name());
-
-        let req = TestRequest::with_header("content-type", "application/json").finish();
-        assert_eq!(UTF_8.name(), req.encoding().unwrap().name());
-
-        let req = TestRequest::with_header(
-            "content-type",
-            "application/json; charset=ISO-8859-2",
-        )
-        .finish();
-        assert_eq!(ISO_8859_2, req.encoding().unwrap());
-    }
-
-    #[test]
-    fn test_encoding_error() {
-        let req = TestRequest::with_header("content-type", "applicatjson").finish();
-        assert_eq!(Some(ContentTypeError::ParseError), req.encoding().err());
-
-        let req = TestRequest::with_header(
-            "content-type",
-            "application/json; charset=kkkttktk",
-        )
-        .finish();
-        assert_eq!(
-            Some(ContentTypeError::UnknownEncoding),
-            req.encoding().err()
-        );
-    }
-
-    #[test]
-    fn test_chunked() {
-        let req = TestRequest::default().finish();
-        assert!(!req.chunked().unwrap());
-
-        let req =
-            TestRequest::with_header(header::TRANSFER_ENCODING, "chunked").finish();
-        assert!(req.chunked().unwrap());
-
-        let req = TestRequest::default()
-            .header(
-                header::TRANSFER_ENCODING,
-                Bytes::from_static(b"some va\xadscc\xacas0xsdasdlue"),
-            )
-            .finish();
-        assert!(req.chunked().is_err());
-    }
-}
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@@ -1,66 +0,0 @@
-//! Basic http primitives for actix-net framework.
-#![allow(
-    clippy::type_complexity,
-    clippy::too_many_arguments,
-    clippy::new_without_default,
-    clippy::borrow_interior_mutable_const,
-    clippy::write_with_newline
-)]
-
-#[macro_use]
-extern crate log;
-
-pub mod body;
-mod builder;
-pub mod client;
-mod cloneable;
-mod config;
-pub mod encoding;
-mod extensions;
-mod header;
-mod helpers;
-mod httpcodes;
-pub mod httpmessage;
-mod message;
-mod payload;
-mod request;
-mod response;
-mod service;
-
-pub mod cookie;
-pub mod error;
-pub mod h1;
-pub mod h2;
-pub mod test;
-pub mod ws;
-
-pub use self::builder::HttpServiceBuilder;
-pub use self::config::{KeepAlive, ServiceConfig};
-pub use self::error::{Error, ResponseError, Result};
-pub use self::extensions::Extensions;
-pub use self::httpmessage::HttpMessage;
-pub use self::message::{Message, RequestHead, RequestHeadType, ResponseHead};
-pub use self::payload::{Payload, PayloadStream};
-pub use self::request::Request;
-pub use self::response::{Response, ResponseBuilder};
-pub use self::service::HttpService;
-
-pub mod http {
-    //! Various HTTP related types
-
-    // re-exports
-    pub use http::header::{HeaderName, HeaderValue};
-    pub use http::uri::PathAndQuery;
-    pub use http::{uri, Error, HttpTryFrom, Uri};
-    pub use http::{Method, StatusCode, Version};
-
-    pub use crate::cookie::{Cookie, CookieBuilder};
-    pub use crate::header::HeaderMap;
-
-    /// Various http headers
-    pub mod header {
-        pub use crate::header::*;
-    }
-    pub use crate::header::ContentEncoding;
-    pub use crate::message::ConnectionType;
-}
--- a/actix-http/src/message.rs
+++ b/actix-http/src/message.rs
@@ -1,487 +0,0 @@
-use std::cell::{Ref, RefCell, RefMut};
-use std::net;
-use std::rc::Rc;
-
-use bitflags::bitflags;
-use copyless::BoxHelper;
-
-use crate::extensions::Extensions;
-use crate::header::HeaderMap;
-use crate::http::{header, Method, StatusCode, Uri, Version};
-
-/// Represents various types of connection
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum ConnectionType {
-    /// Close connection after response
-    Close,
-    /// Keep connection alive after response
-    KeepAlive,
-    /// Connection is upgraded to different type
-    Upgrade,
-}
-
-bitflags! {
-    pub(crate) struct Flags: u8 {
-        const CLOSE       = 0b0000_0001;
-        const KEEP_ALIVE  = 0b0000_0010;
-        const UPGRADE     = 0b0000_0100;
-        const EXPECT      = 0b0000_1000;
-        const NO_CHUNKING = 0b0001_0000;
-        const CAMEL_CASE  = 0b0010_0000;
-    }
-}
-
-#[doc(hidden)]
-pub trait Head: Default + 'static {
-    fn clear(&mut self);
-
-    fn pool() -> &'static MessagePool<Self>;
-}
-
-#[derive(Debug)]
-pub struct RequestHead {
-    pub uri: Uri,
-    pub method: Method,
-    pub version: Version,
-    pub headers: HeaderMap,
-    pub extensions: RefCell<Extensions>,
-    pub peer_addr: Option<net::SocketAddr>,
-    flags: Flags,
-}
-
-impl Default for RequestHead {
-    fn default() -> RequestHead {
-        RequestHead {
-            uri: Uri::default(),
-            method: Method::default(),
-            version: Version::HTTP_11,
-            headers: HeaderMap::with_capacity(16),
-            flags: Flags::empty(),
-            peer_addr: None,
-            extensions: RefCell::new(Extensions::new()),
-        }
-    }
-}
-
-impl Head for RequestHead {
-    fn clear(&mut self) {
-        self.flags = Flags::empty();
-        self.headers.clear();
-        self.extensions.borrow_mut().clear();
-    }
-
-    fn pool() -> &'static MessagePool<Self> {
-        REQUEST_POOL.with(|p| *p)
-    }
-}
-
-impl RequestHead {
-    /// Message extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<Extensions> {
-        self.extensions.borrow()
-    }
-
-    /// Mutable reference to a the message's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<Extensions> {
-        self.extensions.borrow_mut()
-    }
-
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    /// Is to uppercase headers with Camel-Case.
-    /// Befault is `false`
-    #[inline]
-    pub fn camel_case_headers(&self) -> bool {
-        self.flags.contains(Flags::CAMEL_CASE)
-    }
-
-    /// Set `true` to send headers which are uppercased with Camel-Case.
-    #[inline]
-    pub fn set_camel_case_headers(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::CAMEL_CASE);
-        } else {
-            self.flags.remove(Flags::CAMEL_CASE);
-        }
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    /// Connection type
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    /// Connection upgrade status
-    pub fn upgrade(&self) -> bool {
-        if let Some(hdr) = self.headers().get(header::CONNECTION) {
-            if let Ok(s) = hdr.to_str() {
-                s.to_ascii_lowercase().contains("upgrade")
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-
-    #[inline]
-    /// Request contains `EXPECT` header
-    pub fn expect(&self) -> bool {
-        self.flags.contains(Flags::EXPECT)
-    }
-
-    #[inline]
-    pub(crate) fn set_expect(&mut self) {
-        self.flags.insert(Flags::EXPECT);
-    }
-}
-
-#[derive(Debug)]
-pub enum RequestHeadType {
-    Owned(RequestHead),
-    Rc(Rc<RequestHead>, Option<HeaderMap>),
-}
-
-impl RequestHeadType {
-    pub fn extra_headers(&self) -> Option<&HeaderMap> {
-        match self {
-            RequestHeadType::Owned(_) => None,
-            RequestHeadType::Rc(_, headers) => headers.as_ref(),
-        }
-    }
-}
-
-impl AsRef<RequestHead> for RequestHeadType {
-    fn as_ref(&self) -> &RequestHead {
-        match self {
-            RequestHeadType::Owned(head) => &head,
-            RequestHeadType::Rc(head, _) => head.as_ref(),
-        }
-    }
-}
-
-impl From<RequestHead> for RequestHeadType {
-    fn from(head: RequestHead) -> Self {
-        RequestHeadType::Owned(head)
-    }
-}
-
-#[derive(Debug)]
-pub struct ResponseHead {
-    pub version: Version,
-    pub status: StatusCode,
-    pub headers: HeaderMap,
-    pub reason: Option<&'static str>,
-    pub(crate) extensions: RefCell<Extensions>,
-    flags: Flags,
-}
-
-impl ResponseHead {
-    /// Create new instance of `ResponseHead` type
-    #[inline]
-    pub fn new(status: StatusCode) -> ResponseHead {
-        ResponseHead {
-            status,
-            version: Version::default(),
-            headers: HeaderMap::with_capacity(12),
-            reason: None,
-            flags: Flags::empty(),
-            extensions: RefCell::new(Extensions::new()),
-        }
-    }
-
-    /// Message extensions
-    #[inline]
-    pub fn extensions(&self) -> Ref<Extensions> {
-        self.extensions.borrow()
-    }
-
-    /// Mutable reference to a the message's extensions
-    #[inline]
-    pub fn extensions_mut(&self) -> RefMut<Extensions> {
-        self.extensions.borrow_mut()
-    }
-
-    #[inline]
-    /// Read the message headers.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    #[inline]
-    /// Mutable reference to the message headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.headers
-    }
-
-    #[inline]
-    /// Set connection type of the message
-    pub fn set_connection_type(&mut self, ctype: ConnectionType) {
-        match ctype {
-            ConnectionType::Close => self.flags.insert(Flags::CLOSE),
-            ConnectionType::KeepAlive => self.flags.insert(Flags::KEEP_ALIVE),
-            ConnectionType::Upgrade => self.flags.insert(Flags::UPGRADE),
-        }
-    }
-
-    #[inline]
-    pub fn connection_type(&self) -> ConnectionType {
-        if self.flags.contains(Flags::CLOSE) {
-            ConnectionType::Close
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            ConnectionType::KeepAlive
-        } else if self.flags.contains(Flags::UPGRADE) {
-            ConnectionType::Upgrade
-        } else if self.version < Version::HTTP_11 {
-            ConnectionType::Close
-        } else {
-            ConnectionType::KeepAlive
-        }
-    }
-
-    #[inline]
-    /// Check if keep-alive is enabled
-    pub fn keep_alive(&self) -> bool {
-        self.connection_type() == ConnectionType::KeepAlive
-    }
-
-    #[inline]
-    /// Check upgrade status of this message
-    pub fn upgrade(&self) -> bool {
-        self.connection_type() == ConnectionType::Upgrade
-    }
-
-    /// Get custom reason for the response
-    #[inline]
-    pub fn reason(&self) -> &str {
-        if let Some(reason) = self.reason {
-            reason
-        } else {
-            self.status
-                .canonical_reason()
-                .unwrap_or("<unknown status code>")
-        }
-    }
-
-    #[inline]
-    pub(crate) fn ctype(&self) -> Option<ConnectionType> {
-        if self.flags.contains(Flags::CLOSE) {
-            Some(ConnectionType::Close)
-        } else if self.flags.contains(Flags::KEEP_ALIVE) {
-            Some(ConnectionType::KeepAlive)
-        } else if self.flags.contains(Flags::UPGRADE) {
-            Some(ConnectionType::Upgrade)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    /// Get response body chunking state
-    pub fn chunked(&self) -> bool {
-        !self.flags.contains(Flags::NO_CHUNKING)
-    }
-
-    #[inline]
-    /// Set no chunking for payload
-    pub fn no_chunking(&mut self, val: bool) {
-        if val {
-            self.flags.insert(Flags::NO_CHUNKING);
-        } else {
-            self.flags.remove(Flags::NO_CHUNKING);
-        }
-    }
-}
-
-pub struct Message<T: Head> {
-    head: Rc<T>,
-}
-
-impl<T: Head> Message<T> {
-    /// Get new message from the pool of objects
-    pub fn new() -> Self {
-        T::pool().get_message()
-    }
-}
-
-impl<T: Head> Clone for Message<T> {
-    fn clone(&self) -> Self {
-        Message {
-            head: self.head.clone(),
-        }
-    }
-}
-
-impl<T: Head> std::ops::Deref for Message<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.head.as_ref()
-    }
-}
-
-impl<T: Head> std::ops::DerefMut for Message<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        Rc::get_mut(&mut self.head).expect("Multiple copies exist")
-    }
-}
-
-impl<T: Head> Drop for Message<T> {
-    fn drop(&mut self) {
-        if Rc::strong_count(&self.head) == 1 {
-            T::pool().release(self.head.clone());
-        }
-    }
-}
-
-pub(crate) struct BoxedResponseHead {
-    head: Option<Box<ResponseHead>>,
-}
-
-impl BoxedResponseHead {
-    /// Get new message from the pool of objects
-    pub fn new(status: StatusCode) -> Self {
-        RESPONSE_POOL.with(|p| p.get_message(status))
-    }
-}
-
-impl std::ops::Deref for BoxedResponseHead {
-    type Target = ResponseHead;
-
-    fn deref(&self) -> &Self::Target {
-        self.head.as_ref().unwrap()
-    }
-}
-
-impl std::ops::DerefMut for BoxedResponseHead {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.head.as_mut().unwrap()
-    }
-}
-
-impl Drop for BoxedResponseHead {
-    fn drop(&mut self) {
-        RESPONSE_POOL.with(|p| p.release(self.head.take().unwrap()))
-    }
-}
-
-#[doc(hidden)]
-/// Request's objects pool
-pub struct MessagePool<T: Head>(RefCell<Vec<Rc<T>>>);
-
-#[doc(hidden)]
-#[allow(clippy::vec_box)]
-/// Request's objects pool
-pub struct BoxedResponsePool(RefCell<Vec<Box<ResponseHead>>>);
-
-thread_local!(static REQUEST_POOL: &'static MessagePool<RequestHead> = MessagePool::<RequestHead>::create());
-thread_local!(static RESPONSE_POOL: &'static BoxedResponsePool = BoxedResponsePool::create());
-
-impl<T: Head> MessagePool<T> {
-    fn create() -> &'static MessagePool<T> {
-        let pool = MessagePool(RefCell::new(Vec::with_capacity(128)));
-        Box::leak(Box::new(pool))
-    }
-
-    /// Get message from the pool
-    #[inline]
-    fn get_message(&'static self) -> Message<T> {
-        if let Some(mut msg) = self.0.borrow_mut().pop() {
-            if let Some(r) = Rc::get_mut(&mut msg) {
-                r.clear();
-            }
-            Message { head: msg }
-        } else {
-            Message {
-                head: Rc::new(T::default()),
-            }
-        }
-    }
-
-    #[inline]
-    /// Release request instance
-    fn release(&self, msg: Rc<T>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            v.push(msg);
-        }
-    }
-}
-
-impl BoxedResponsePool {
-    fn create() -> &'static BoxedResponsePool {
-        let pool = BoxedResponsePool(RefCell::new(Vec::with_capacity(128)));
-        Box::leak(Box::new(pool))
-    }
-
-    /// Get message from the pool
-    #[inline]
-    fn get_message(&'static self, status: StatusCode) -> BoxedResponseHead {
-        if let Some(mut head) = self.0.borrow_mut().pop() {
-            head.reason = None;
-            head.status = status;
-            head.headers.clear();
-            head.flags = Flags::empty();
-            BoxedResponseHead { head: Some(head) }
-        } else {
-            BoxedResponseHead {
-                head: Some(Box::alloc().init(ResponseHead::new(status))),
-            }
-        }
-    }
-
-    #[inline]
-    /// Release request instance
-    fn release(&self, msg: Box<ResponseHead>) {
-        let v = &mut self.0.borrow_mut();
-        if v.len() < 128 {
-            msg.extensions.borrow_mut().clear();
-            v.push(msg);
-        }
-    }
-}
--- a/actix-http/src/payload.rs
+++ b/actix-http/src/payload.rs
@@ -1,65 +0,0 @@
-use bytes::Bytes;
-use futures::{Async, Poll, Stream};
-use h2::RecvStream;
-
-use crate::error::PayloadError;
-
-/// Type represent boxed payload
-pub type PayloadStream = Box<dyn Stream<Item = Bytes, Error = PayloadError>>;
-
-/// Type represent streaming payload
-pub enum Payload<S = PayloadStream> {
-    None,
-    H1(crate::h1::Payload),
-    H2(crate::h2::Payload),
-    Stream(S),
-}
-
-impl<S> From<crate::h1::Payload> for Payload<S> {
-    fn from(v: crate::h1::Payload) -> Self {
-        Payload::H1(v)
-    }
-}
-
-impl<S> From<crate::h2::Payload> for Payload<S> {
-    fn from(v: crate::h2::Payload) -> Self {
-        Payload::H2(v)
-    }
-}
-
-impl<S> From<RecvStream> for Payload<S> {
-    fn from(v: RecvStream) -> Self {
-        Payload::H2(crate::h2::Payload::new(v))
-    }
-}
-
-impl From<PayloadStream> for Payload {
-    fn from(pl: PayloadStream) -> Self {
-        Payload::Stream(pl)
-    }
-}
-
-impl<S> Payload<S> {
-    /// Takes current payload and replaces it with `None` value
-    pub fn take(&mut self) -> Payload<S> {
-        std::mem::replace(self, Payload::None)
-    }
-}
-
-impl<S> Stream for Payload<S>
-where
-    S: Stream<Item = Bytes, Error = PayloadError>,
-{
-    type Item = Bytes;
-    type Error = PayloadError;
-
-    #[inline]
-    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
-        match self {
-            Payload::None => Ok(Async::Ready(None)),
-            Payload::H1(ref mut pl) => pl.poll(),
-            Payload::H2(ref mut pl) => pl.poll(),
-            Payload::Stream(ref mut pl) => pl.poll(),
-        }
-    }
-}
--- a/actix-http/src/request.rs
+++ b/actix-http/src/request.rs
@@ -1,205 +0,0 @@
-use std::cell::{Ref, RefMut};
-use std::{fmt, net};
-
-use http::{header, Method, Uri, Version};
-
-use crate::extensions::Extensions;
-use crate::header::HeaderMap;
-use crate::httpmessage::HttpMessage;
-use crate::message::{Message, RequestHead};
-use crate::payload::{Payload, PayloadStream};
-
-/// Request
-pub struct Request<P = PayloadStream> {
-    pub(crate) payload: Payload<P>,
-    pub(crate) head: Message<RequestHead>,
-}
-
-impl<P> HttpMessage for Request<P> {
-    type Stream = P;
-
-    #[inline]
-    fn headers(&self) -> &HeaderMap {
-        &self.head().headers
-    }
-
-    /// Request extensions
-    #[inline]
-    fn extensions(&self) -> Ref<Extensions> {
-        self.head.extensions()
-    }
-
-    /// Mutable reference to a the request's extensions
-    #[inline]
-    fn extensions_mut(&self) -> RefMut<Extensions> {
-        self.head.extensions_mut()
-    }
-
-    fn take_payload(&mut self) -> Payload<P> {
-        std::mem::replace(&mut self.payload, Payload::None)
-    }
-}
-
-impl From<Message<RequestHead>> for Request<PayloadStream> {
-    fn from(head: Message<RequestHead>) -> Self {
-        Request {
-            head,
-            payload: Payload::None,
-        }
-    }
-}
-
-impl Request<PayloadStream> {
-    /// Create new Request instance
-    pub fn new() -> Request<PayloadStream> {
-        Request {
-            head: Message::new(),
-            payload: Payload::None,
-        }
-    }
-}
-
-impl<P> Request<P> {
-    /// Create new Request instance
-    pub fn with_payload(payload: Payload<P>) -> Request<P> {
-        Request {
-            payload,
-            head: Message::new(),
-        }
-    }
-
-    /// Create new Request instance
-    pub fn replace_payload<P1>(self, payload: Payload<P1>) -> (Request<P1>, Payload<P>) {
-        let pl = self.payload;
-        (
-            Request {
-                payload,
-                head: self.head,
-            },
-            pl,
-        )
-    }
-
-    /// Get request's payload
-    pub fn take_payload(&mut self) -> Payload<P> {
-        std::mem::replace(&mut self.payload, Payload::None)
-    }
-
-    /// Split request into request head and payload
-    pub fn into_parts(self) -> (Message<RequestHead>, Payload<P>) {
-        (self.head, self.payload)
-    }
-
-    #[inline]
-    /// Http message part of the request
-    pub fn head(&self) -> &RequestHead {
-        &*self.head
-    }
-
-    #[inline]
-    #[doc(hidden)]
-    /// Mutable reference to a http message part of the request
-    pub fn head_mut(&mut self) -> &mut RequestHead {
-        &mut *self.head
-    }
-
-    /// Mutable reference to the message's headers.
-    pub fn headers_mut(&mut self) -> &mut HeaderMap {
-        &mut self.head_mut().headers
-    }
-
-    /// Request's uri.
-    #[inline]
-    pub fn uri(&self) -> &Uri {
-        &self.head().uri
-    }
-
-    /// Mutable reference to the request's uri.
-    #[inline]
-    pub fn uri_mut(&mut self) -> &mut Uri {
-        &mut self.head_mut().uri
-    }
-
-    /// Read the Request method.
-    #[inline]
-    pub fn method(&self) -> &Method {
-        &self.head().method
-    }
-
-    /// Read the Request Version.
-    #[inline]
-    pub fn version(&self) -> Version {
-        self.head().version
-    }
-
-    /// The target path of this Request.
-    #[inline]
-    pub fn path(&self) -> &str {
-        self.head().uri.path()
-    }
-
-    /// Check if request requires connection upgrade
-    #[inline]
-    pub fn upgrade(&self) -> bool {
-        if let Some(conn) = self.head().headers.get(header::CONNECTION) {
-            if let Ok(s) = conn.to_str() {
-                return s.to_lowercase().contains("upgrade");
-            }
-        }
-        self.head().method == Method::CONNECT
-    }
-
-    /// Peer socket address
-    ///
-    /// Peer address is actual socket address, if proxy is used in front of
-    /// actix http server, then peer address would be address of this proxy.
-    #[inline]
-    pub fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.head().peer_addr
-    }
-}
-
-impl<P> fmt::Debug for Request<P> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(
-            f,
-            "\nRequest {:?} {}:{}",
-            self.version(),
-            self.method(),
-            self.path()
-        )?;
-        if let Some(q) = self.uri().query().as_ref() {
-            writeln!(f, "  query: ?{:?}", q)?;
-        }
-        writeln!(f, "  headers:")?;
-        for (key, val) in self.headers() {
-            writeln!(f, "    {:?}: {:?}", key, val)?;
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use http::HttpTryFrom;
-
-    #[test]
-    fn test_basics() {
-        let msg = Message::new();
-        let mut req = Request::from(msg);
-        req.headers_mut().insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static("text/plain"),
-        );
-        assert!(req.headers().contains_key(header::CONTENT_TYPE));
-
-        *req.uri_mut() = Uri::try_from("/index.html?q=1").unwrap();
-        assert_eq!(req.uri().path(), "/index.html");
-        assert_eq!(req.uri().query(), Some("q=1"));
-
-        let s = format!("{:?}", req);
-        println!("T: {:?}", s);
-        assert!(s.contains("Request HTTP/1.1 GET:/index.html"));
-    }
-}
--- a/actix-http/src/response.rs
+++ b/actix-http/src/response.rs
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@@ -1,605 +0,0 @@
-use std::marker::PhantomData;
-use std::{fmt, io, net, rc};
-
-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_server_config::{
-    Io as ServerIo, IoStream, Protocol, ServerConfig as SrvConfig,
-};
-use actix_service::{IntoNewService, NewService, Service};
-use bytes::{Buf, BufMut, Bytes, BytesMut};
-use futures::{try_ready, Async, Future, IntoFuture, Poll};
-use h2::server::{self, Handshake};
-
-use crate::body::MessageBody;
-use crate::builder::HttpServiceBuilder;
-use crate::cloneable::CloneableService;
-use crate::config::{KeepAlive, ServiceConfig};
-use crate::error::{DispatchError, Error};
-use crate::helpers::DataFactory;
-use crate::request::Request;
-use crate::response::Response;
-use crate::{h1, h2::Dispatcher};
-
-/// `NewService` HTTP1.1/HTTP2 transport implementation
-pub struct HttpService<T, P, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler<T>> {
-    srv: S,
-    cfg: ServiceConfig,
-    expect: X,
-    upgrade: Option<U>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, S, B> HttpService<T, (), S, B>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create builder for `HttpService` instance.
-    pub fn build() -> HttpServiceBuilder<T, S> {
-        HttpServiceBuilder::new()
-    }
-}
-
-impl<T, P, S, B> HttpService<T, P, S, B>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    /// Create new `HttpService` instance.
-    pub fn new<F: IntoNewService<S>>(service: F) -> Self {
-        let cfg = ServiceConfig::new(KeepAlive::Timeout(5), 5000, 0);
-
-        HttpService {
-            cfg,
-            srv: service.into_new_service(),
-            expect: h1::ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-
-    /// Create new `HttpService` instance with config.
-    pub(crate) fn with_config<F: IntoNewService<S>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
-        HttpService {
-            cfg,
-            srv: service.into_new_service(),
-            expect: h1::ExpectHandler,
-            upgrade: None,
-            on_connect: None,
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P, S, B, X, U> HttpService<T, P, S, B, X, U>
-where
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-{
-    /// Provide service for `EXPECT: 100-Continue` support.
-    ///
-    /// Service get called with request that contains `EXPECT` header.
-    /// Service must return request in case of success, in that case
-    /// request will be forwarded to main service.
-    pub fn expect<X1>(self, expect: X1) -> HttpService<T, P, S, B, X1, U>
-    where
-        X1: NewService<Config = SrvConfig, Request = Request, Response = Request>,
-        X1::Error: Into<Error>,
-        X1::InitError: fmt::Debug,
-    {
-        HttpService {
-            expect,
-            cfg: self.cfg,
-            srv: self.srv,
-            upgrade: self.upgrade,
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Provide service for custom `Connection: UPGRADE` support.
-    ///
-    /// If service is provided then normal requests handling get halted
-    /// and this service get called with original request and framed object.
-    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, P, S, B, X, U1>
-    where
-        U1: NewService<
-            Config = SrvConfig,
-            Request = (Request, Framed<T, h1::Codec>),
-            Response = (),
-        >,
-        U1::Error: fmt::Display,
-        U1::InitError: fmt::Debug,
-    {
-        HttpService {
-            upgrade,
-            cfg: self.cfg,
-            srv: self.srv,
-            expect: self.expect,
-            on_connect: self.on_connect,
-            _t: PhantomData,
-        }
-    }
-
-    /// Set on connect callback.
-    pub(crate) fn on_connect(
-        mut self,
-        f: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> Self {
-        self.on_connect = f;
-        self
-    }
-}
-
-impl<T, P, S, B, X, U> NewService for HttpService<T, P, S, B, X, U>
-where
-    T: IoStream,
-    S: NewService<Config = SrvConfig, Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: NewService<
-        Config = SrvConfig,
-        Request = (Request, Framed<T, h1::Codec>),
-        Response = (),
-    >,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    type Config = SrvConfig;
-    type Request = ServerIo<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type InitError = ();
-    type Service = HttpServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
-    type Future = HttpServiceResponse<T, P, S, B, X, U>;
-
-    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
-        HttpServiceResponse {
-            fut: self.srv.new_service(cfg).into_future(),
-            fut_ex: Some(self.expect.new_service(cfg)),
-            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(cfg)),
-            expect: None,
-            upgrade: None,
-            on_connect: self.on_connect.clone(),
-            cfg: Some(self.cfg.clone()),
-            _t: PhantomData,
-        }
-    }
-}
-
-#[doc(hidden)]
-pub struct HttpServiceResponse<T, P, S: NewService, B, X: NewService, U: NewService> {
-    fut: S::Future,
-    fut_ex: Option<X::Future>,
-    fut_upg: Option<U::Future>,
-    expect: Option<X::Service>,
-    upgrade: Option<U::Service>,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    cfg: Option<ServiceConfig>,
-    _t: PhantomData<(T, P, B)>,
-}
-
-impl<T, P, S, B, X, U> Future for HttpServiceResponse<T, P, S, B, X, U>
-where
-    T: IoStream,
-    S: NewService<Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-    X: NewService<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: NewService<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-    U::InitError: fmt::Debug,
-{
-    type Item = HttpServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        if let Some(ref mut fut) = self.fut_ex {
-            let expect = try_ready!(fut
-                .poll()
-                .map_err(|e| log::error!("Init http service error: {:?}", e)));
-            self.expect = Some(expect);
-            self.fut_ex.take();
-        }
-
-        if let Some(ref mut fut) = self.fut_upg {
-            let upgrade = try_ready!(fut
-                .poll()
-                .map_err(|e| log::error!("Init http service error: {:?}", e)));
-            self.upgrade = Some(upgrade);
-            self.fut_ex.take();
-        }
-
-        let service = try_ready!(self
-            .fut
-            .poll()
-            .map_err(|e| log::error!("Init http service error: {:?}", e)));
-        Ok(Async::Ready(HttpServiceHandler::new(
-            self.cfg.take().unwrap(),
-            service,
-            self.expect.take().unwrap(),
-            self.upgrade.take(),
-            self.on_connect.clone(),
-        )))
-    }
-}
-
-/// `Service` implementation for http transport
-pub struct HttpServiceHandler<T, P, S, B, X, U> {
-    srv: CloneableService<S>,
-    expect: CloneableService<X>,
-    upgrade: Option<CloneableService<U>>,
-    cfg: ServiceConfig,
-    on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    _t: PhantomData<(T, P, B, X)>,
-}
-
-impl<T, P, S, B, X, U> HttpServiceHandler<T, P, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    fn new(
-        cfg: ServiceConfig,
-        srv: S,
-        expect: X,
-        upgrade: Option<U>,
-        on_connect: Option<rc::Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> HttpServiceHandler<T, P, S, B, X, U> {
-        HttpServiceHandler {
-            cfg,
-            on_connect,
-            srv: CloneableService::new(srv),
-            expect: CloneableService::new(expect),
-            upgrade: upgrade.map(CloneableService::new),
-            _t: PhantomData,
-        }
-    }
-}
-
-impl<T, P, S, B, X, U> Service for HttpServiceHandler<T, P, S, B, X, U>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    type Request = ServerIo<T, P>;
-    type Response = ();
-    type Error = DispatchError;
-    type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
-
-    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
-        let ready = self
-            .expect
-            .poll_ready()
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready();
-
-        let ready = self
-            .srv
-            .poll_ready()
-            .map_err(|e| {
-                let e = e.into();
-                log::error!("Http service readiness error: {:?}", e);
-                DispatchError::Service(e)
-            })?
-            .is_ready()
-            && ready;
-
-        if ready {
-            Ok(Async::Ready(()))
-        } else {
-            Ok(Async::NotReady)
-        }
-    }
-
-    fn call(&mut self, req: Self::Request) -> Self::Future {
-        let (io, _, proto) = req.into_parts();
-
-        let on_connect = if let Some(ref on_connect) = self.on_connect {
-            Some(on_connect(&io))
-        } else {
-            None
-        };
-
-        match proto {
-            Protocol::Http2 => {
-                let peer_addr = io.peer_addr();
-                let io = Io {
-                    inner: io,
-                    unread: None,
-                };
-                HttpServiceHandlerResponse {
-                    state: State::Handshake(Some((
-                        server::handshake(io),
-                        self.cfg.clone(),
-                        self.srv.clone(),
-                        peer_addr,
-                        on_connect,
-                    ))),
-                }
-            }
-            Protocol::Http10 | Protocol::Http11 => HttpServiceHandlerResponse {
-                state: State::H1(h1::Dispatcher::new(
-                    io,
-                    self.cfg.clone(),
-                    self.srv.clone(),
-                    self.expect.clone(),
-                    self.upgrade.clone(),
-                    on_connect,
-                )),
-            },
-            _ => HttpServiceHandlerResponse {
-                state: State::Unknown(Some((
-                    io,
-                    BytesMut::with_capacity(14),
-                    self.cfg.clone(),
-                    self.srv.clone(),
-                    self.expect.clone(),
-                    self.upgrade.clone(),
-                    on_connect,
-                ))),
-            },
-        }
-    }
-}
-
-enum State<T, S, B, X, U>
-where
-    S: Service<Request = Request>,
-    S::Future: 'static,
-    S::Error: Into<Error>,
-    T: IoStream,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    H1(h1::Dispatcher<T, S, B, X, U>),
-    H2(Dispatcher<Io<T>, S, B>),
-    Unknown(
-        Option<(
-            T,
-            BytesMut,
-            ServiceConfig,
-            CloneableService<S>,
-            CloneableService<X>,
-            Option<CloneableService<U>>,
-            Option<Box<dyn DataFactory>>,
-        )>,
-    ),
-    Handshake(
-        Option<(
-            Handshake<Io<T>, Bytes>,
-            ServiceConfig,
-            CloneableService<S>,
-            Option<net::SocketAddr>,
-            Option<Box<dyn DataFactory>>,
-        )>,
-    ),
-}
-
-pub struct HttpServiceHandlerResponse<T, S, B, X, U>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody + 'static,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    state: State<T, S, B, X, U>,
-}
-
-const HTTP2_PREFACE: [u8; 14] = *b"PRI * HTTP/2.0";
-
-impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
-where
-    T: IoStream,
-    S: Service<Request = Request>,
-    S::Error: Into<Error>,
-    S::Future: 'static,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: Service<Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
-    U::Error: fmt::Display,
-{
-    type Item = ();
-    type Error = DispatchError;
-
-    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
-        match self.state {
-            State::H1(ref mut disp) => disp.poll(),
-            State::H2(ref mut disp) => disp.poll(),
-            State::Unknown(ref mut data) => {
-                if let Some(ref mut item) = data {
-                    loop {
-                        // Safety - we only write to the returned slice.
-                        let b = unsafe { item.1.bytes_mut() };
-                        let n = try_ready!(item.0.poll_read(b));
-                        if n == 0 {
-                            return Ok(Async::Ready(()));
-                        }
-                        // Safety - we know that 'n' bytes have
-                        // been initialized via the contract of
-                        // 'poll_read'
-                        unsafe { item.1.advance_mut(n) };
-                        if item.1.len() >= HTTP2_PREFACE.len() {
-                            break;
-                        }
-                    }
-                } else {
-                    panic!()
-                }
-                let (io, buf, cfg, srv, expect, upgrade, on_connect) =
-                    data.take().unwrap();
-                if buf[..14] == HTTP2_PREFACE[..] {
-                    let peer_addr = io.peer_addr();
-                    let io = Io {
-                        inner: io,
-                        unread: Some(buf),
-                    };
-                    self.state = State::Handshake(Some((
-                        server::handshake(io),
-                        cfg,
-                        srv,
-                        peer_addr,
-                        on_connect,
-                    )));
-                } else {
-                    self.state = State::H1(h1::Dispatcher::with_timeout(
-                        io,
-                        h1::Codec::new(cfg.clone()),
-                        cfg,
-                        buf,
-                        None,
-                        srv,
-                        expect,
-                        upgrade,
-                        on_connect,
-                    ))
-                }
-                self.poll()
-            }
-            State::Handshake(ref mut data) => {
-                let conn = if let Some(ref mut item) = data {
-                    match item.0.poll() {
-                        Ok(Async::Ready(conn)) => conn,
-                        Ok(Async::NotReady) => return Ok(Async::NotReady),
-                        Err(err) => {
-                            trace!("H2 handshake error: {}", err);
-                            return Err(err.into());
-                        }
-                    }
-                } else {
-                    panic!()
-                };
-                let (_, cfg, srv, peer_addr, on_connect) = data.take().unwrap();
-                self.state = State::H2(Dispatcher::new(
-                    srv, conn, on_connect, cfg, None, peer_addr,
-                ));
-                self.poll()
-            }
-        }
-    }
-}
-
-/// Wrapper for `AsyncRead + AsyncWrite` types
-struct Io<T> {
-    unread: Option<BytesMut>,
-    inner: T,
-}
-
-impl<T: io::Read> io::Read for Io<T> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        if let Some(mut bytes) = self.unread.take() {
-            let size = std::cmp::min(buf.len(), bytes.len());
-            buf[..size].copy_from_slice(&bytes[..size]);
-            if bytes.len() > size {
-                bytes.split_to(size);
-                self.unread = Some(bytes);
-            }
-            Ok(size)
-        } else {
-            self.inner.read(buf)
-        }
-    }
-}
-
-impl<T: io::Write> io::Write for Io<T> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.write(buf)
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        self.inner.flush()
-    }
-}
-
-impl<T: AsyncRead> AsyncRead for Io<T> {
-    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
-        self.inner.prepare_uninitialized_buffer(buf)
-    }
-}
-
-impl<T: AsyncWrite> AsyncWrite for Io<T> {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        self.inner.shutdown()
-    }
-    fn write_buf<B: Buf>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
-        self.inner.write_buf(buf)
-    }
-}
-
-impl<T: IoStream> IoStream for Io<T> {
-    #[inline]
-    fn peer_addr(&self) -> Option<net::SocketAddr> {
-        self.inner.peer_addr()
-    }
-
-    #[inline]
-    fn set_nodelay(&mut self, nodelay: bool) -> io::Result<()> {
-        self.inner.set_nodelay(nodelay)
-    }
-
-    #[inline]
-    fn set_linger(&mut self, dur: Option<std::time::Duration>) -> io::Result<()> {
-        self.inner.set_linger(dur)
-    }
-
-    #[inline]
-    fn set_keepalive(&mut self, dur: Option<std::time::Duration>) -> io::Result<()> {
-        self.inner.set_keepalive(dur)
-    }
-}
--- a/actix-http/src/test.rs
+++ b/actix-http/src/test.rs
@@ -1,270 +0,0 @@
-//! Test Various helpers for Actix applications to use during testing.
-use std::fmt::Write as FmtWrite;
-use std::io;
-use std::str::FromStr;
-
-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_server_config::IoStream;
-use bytes::{Buf, Bytes, BytesMut};
-use futures::{Async, Poll};
-use http::header::{self, HeaderName, HeaderValue};
-use http::{HttpTryFrom, Method, Uri, Version};
-use percent_encoding::percent_encode;
-
-use crate::cookie::{Cookie, CookieJar, USERINFO};
-use crate::header::HeaderMap;
-use crate::header::{Header, IntoHeaderValue};
-use crate::payload::Payload;
-use crate::Request;
-
-/// Test `Request` builder
-///
-/// ```rust,ignore
-/// # extern crate http;
-/// # extern crate actix_web;
-/// # use http::{header, StatusCode};
-/// # use actix_web::*;
-/// use actix_web::test::TestRequest;
-///
-/// fn index(req: &HttpRequest) -> Response {
-///     if let Some(hdr) = req.headers().get(header::CONTENT_TYPE) {
-///         Response::Ok().into()
-///     } else {
-///         Response::BadRequest().into()
-///     }
-/// }
-///
-/// fn main() {
-///     let resp = TestRequest::with_header("content-type", "text/plain")
-///         .run(&index)
-///         .unwrap();
-///     assert_eq!(resp.status(), StatusCode::OK);
-///
-///     let resp = TestRequest::default().run(&index).unwrap();
-///     assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-/// }
-/// ```
-pub struct TestRequest(Option<Inner>);
-
-struct Inner {
-    version: Version,
-    method: Method,
-    uri: Uri,
-    headers: HeaderMap,
-    cookies: CookieJar,
-    payload: Option<Payload>,
-}
-
-impl Default for TestRequest {
-    fn default() -> TestRequest {
-        TestRequest(Some(Inner {
-            method: Method::GET,
-            uri: Uri::from_str("/").unwrap(),
-            version: Version::HTTP_11,
-            headers: HeaderMap::new(),
-            cookies: CookieJar::new(),
-            payload: None,
-        }))
-    }
-}
-
-impl TestRequest {
-    /// Create TestRequest and set request uri
-    pub fn with_uri(path: &str) -> TestRequest {
-        TestRequest::default().uri(path).take()
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_hdr<H: Header>(hdr: H) -> TestRequest {
-        TestRequest::default().set(hdr).take()
-    }
-
-    /// Create TestRequest and set header
-    pub fn with_header<K, V>(key: K, value: V) -> TestRequest
-    where
-        HeaderName: HttpTryFrom<K>,
-        V: IntoHeaderValue,
-    {
-        TestRequest::default().header(key, value).take()
-    }
-
-    /// Set HTTP version of this request
-    pub fn version(&mut self, ver: Version) -> &mut Self {
-        parts(&mut self.0).version = ver;
-        self
-    }
-
-    /// Set HTTP method of this request
-    pub fn method(&mut self, meth: Method) -> &mut Self {
-        parts(&mut self.0).method = meth;
-        self
-    }
-
-    /// Set HTTP Uri of this request
-    pub fn uri(&mut self, path: &str) -> &mut Self {
-        parts(&mut self.0).uri = Uri::from_str(path).unwrap();
-        self
-    }
-
-    /// Set a header
-    pub fn set<H: Header>(&mut self, hdr: H) -> &mut Self {
-        if let Ok(value) = hdr.try_into() {
-            parts(&mut self.0).headers.append(H::name(), value);
-            return self;
-        }
-        panic!("Can not set header");
-    }
-
-    /// Set a header
-    pub fn header<K, V>(&mut self, key: K, value: V) -> &mut Self
-    where
-        HeaderName: HttpTryFrom<K>,
-        V: IntoHeaderValue,
-    {
-        if let Ok(key) = HeaderName::try_from(key) {
-            if let Ok(value) = value.try_into() {
-                parts(&mut self.0).headers.append(key, value);
-                return self;
-            }
-        }
-        panic!("Can not create header");
-    }
-
-    /// Set cookie for this request
-    pub fn cookie<'a>(&mut self, cookie: Cookie<'a>) -> &mut Self {
-        parts(&mut self.0).cookies.add(cookie.into_owned());
-        self
-    }
-
-    /// Set request payload
-    pub fn set_payload<B: Into<Bytes>>(&mut self, data: B) -> &mut Self {
-        let mut payload = crate::h1::Payload::empty();
-        payload.unread_data(data.into());
-        parts(&mut self.0).payload = Some(payload.into());
-        self
-    }
-
-    pub fn take(&mut self) -> TestRequest {
-        TestRequest(self.0.take())
-    }
-
-    /// Complete request creation and generate `Request` instance
-    pub fn finish(&mut self) -> Request {
-        let inner = self.0.take().expect("cannot reuse test request builder");
-
-        let mut req = if let Some(pl) = inner.payload {
-            Request::with_payload(pl)
-        } else {
-            Request::with_payload(crate::h1::Payload::empty().into())
-        };
-
-        let head = req.head_mut();
-        head.uri = inner.uri;
-        head.method = inner.method;
-        head.version = inner.version;
-        head.headers = inner.headers;
-
-        let mut cookie = String::new();
-        for c in inner.cookies.delta() {
-            let name = percent_encode(c.name().as_bytes(), USERINFO);
-            let value = percent_encode(c.value().as_bytes(), USERINFO);
-            let _ = write!(&mut cookie, "; {}={}", name, value);
-        }
-        if !cookie.is_empty() {
-            head.headers.insert(
-                header::COOKIE,
-                HeaderValue::from_str(&cookie.as_str()[2..]).unwrap(),
-            );
-        }
-
-        req
-    }
-}
-
-#[inline]
-fn parts(parts: &mut Option<Inner>) -> &mut Inner {
-    parts.as_mut().expect("cannot reuse test request builder")
-}
-
-/// Async io buffer
-pub struct TestBuffer {
-    pub read_buf: BytesMut,
-    pub write_buf: BytesMut,
-    pub err: Option<io::Error>,
-}
-
-impl TestBuffer {
-    /// Create new TestBuffer instance
-    pub fn new<T>(data: T) -> TestBuffer
-    where
-        BytesMut: From<T>,
-    {
-        TestBuffer {
-            read_buf: BytesMut::from(data),
-            write_buf: BytesMut::new(),
-            err: None,
-        }
-    }
-
-    /// Create new empty TestBuffer instance
-    pub fn empty() -> TestBuffer {
-        TestBuffer::new("")
-    }
-
-    /// Add extra data to read buffer.
-    pub fn extend_read_buf<T: AsRef<[u8]>>(&mut self, data: T) {
-        self.read_buf.extend_from_slice(data.as_ref())
-    }
-}
-
-impl io::Read for TestBuffer {
-    fn read(&mut self, dst: &mut [u8]) -> Result<usize, io::Error> {
-        if self.read_buf.is_empty() {
-            if self.err.is_some() {
-                Err(self.err.take().unwrap())
-            } else {
-                Err(io::Error::new(io::ErrorKind::WouldBlock, ""))
-            }
-        } else {
-            let size = std::cmp::min(self.read_buf.len(), dst.len());
-            let b = self.read_buf.split_to(size);
-            dst[..size].copy_from_slice(&b);
-            Ok(size)
-        }
-    }
-}
-
-impl io::Write for TestBuffer {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.write_buf.extend(buf);
-        Ok(buf.len())
-    }
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl AsyncRead for TestBuffer {}
-
-impl AsyncWrite for TestBuffer {
-    fn shutdown(&mut self) -> Poll<(), io::Error> {
-        Ok(Async::Ready(()))
-    }
-    fn write_buf<B: Buf>(&mut self, _: &mut B) -> Poll<usize, io::Error> {
-        Ok(Async::NotReady)
-    }
-}
-
-impl IoStream for TestBuffer {
-    fn set_nodelay(&mut self, _nodelay: bool) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn set_linger(&mut self, _dur: Option<std::time::Duration>) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn set_keepalive(&mut self, _dur: Option<std::time::Duration>) -> io::Result<()> {
-        Ok(())
-    }
-}
--- a/actix-http/src/ws/codec.rs
+++ b/actix-http/src/ws/codec.rs
@@ -1,150 +0,0 @@
-use actix_codec::{Decoder, Encoder};
-use bytes::{Bytes, BytesMut};
-
-use super::frame::Parser;
-use super::proto::{CloseReason, OpCode};
-use super::ProtocolError;
-
-/// `WebSocket` Message
-#[derive(Debug, PartialEq)]
-pub enum Message {
-    /// Text message
-    Text(String),
-    /// Binary message
-    Binary(Bytes),
-    /// Ping message
-    Ping(String),
-    /// Pong message
-    Pong(String),
-    /// Close message with optional reason
-    Close(Option<CloseReason>),
-    /// No-op. Useful for actix-net services
-    Nop,
-}
-
-/// `WebSocket` frame
-#[derive(Debug, PartialEq)]
-pub enum Frame {
-    /// Text frame, codec does not verify utf8 encoding
-    Text(Option<BytesMut>),
-    /// Binary frame
-    Binary(Option<BytesMut>),
-    /// Ping message
-    Ping(String),
-    /// Pong message
-    Pong(String),
-    /// Close message with optional reason
-    Close(Option<CloseReason>),
-}
-
-#[derive(Debug, Copy, Clone)]
-/// WebSockets protocol codec
-pub struct Codec {
-    max_size: usize,
-    server: bool,
-}
-
-impl Codec {
-    /// Create new websocket frames decoder
-    pub fn new() -> Codec {
-        Codec {
-            max_size: 65_536,
-            server: true,
-        }
-    }
-
-    /// Set max frame size
-    ///
-    /// By default max size is set to 64kb
-    pub fn max_size(mut self, size: usize) -> Self {
-        self.max_size = size;
-        self
-    }
-
-    /// Set decoder to client mode.
-    ///
-    /// By default decoder works in server mode.
-    pub fn client_mode(mut self) -> Self {
-        self.server = false;
-        self
-    }
-}
-
-impl Encoder for Codec {
-    type Item = Message;
-    type Error = ProtocolError;
-
-    fn encode(&mut self, item: Message, dst: &mut BytesMut) -> Result<(), Self::Error> {
-        match item {
-            Message::Text(txt) => {
-                Parser::write_message(dst, txt, OpCode::Text, true, !self.server)
-            }
-            Message::Binary(bin) => {
-                Parser::write_message(dst, bin, OpCode::Binary, true, !self.server)
-            }
-            Message::Ping(txt) => {
-                Parser::write_message(dst, txt, OpCode::Ping, true, !self.server)
-            }
-            Message::Pong(txt) => {
-                Parser::write_message(dst, txt, OpCode::Pong, true, !self.server)
-            }
-            Message::Close(reason) => Parser::write_close(dst, reason, !self.server),
-            Message::Nop => (),
-        }
-        Ok(())
-    }
-}
-
-impl Decoder for Codec {
-    type Item = Frame;
-    type Error = ProtocolError;
-
-    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
-        match Parser::parse(src, self.server, self.max_size) {
-            Ok(Some((finished, opcode, payload))) => {
-                // continuation is not supported
-                if !finished {
-                    return Err(ProtocolError::NoContinuation);
-                }
-
-                match opcode {
-                    OpCode::Continue => Err(ProtocolError::NoContinuation),
-                    OpCode::Bad => Err(ProtocolError::BadOpCode),
-                    OpCode::Close => {
-                        if let Some(ref pl) = payload {
-                            let close_reason = Parser::parse_close_payload(pl);
-                            Ok(Some(Frame::Close(close_reason)))
-                        } else {
-                            Ok(Some(Frame::Close(None)))
-                        }
-                    }
-                    OpCode::Ping => {
-                        if let Some(ref pl) = payload {
-                            Ok(Some(Frame::Ping(String::from_utf8_lossy(pl).into())))
-                        } else {
-                            Ok(Some(Frame::Ping(String::new())))
-                        }
-                    }
-                    OpCode::Pong => {
-                        if let Some(ref pl) = payload {
-                            Ok(Some(Frame::Pong(String::from_utf8_lossy(pl).into())))
-                        } else {
-                            Ok(Some(Frame::Pong(String::new())))
-                        }
-                    }
-                    OpCode::Binary => Ok(Some(Frame::Binary(payload))),
-                    OpCode::Text => {
-                        Ok(Some(Frame::Text(payload)))
-                        //let tmp = Vec::from(payload.as_ref());
-                        //match String::from_utf8(tmp) {
-                        //    Ok(s) => Ok(Some(Message::Text(s))),
-                        //    Err(_) => Err(ProtocolError::BadEncoding),
-                        //}
-                    }
-                }
-            }
-            Ok(None) => Ok(None),
-            Err(e) => Err(e),
-        }
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nikolay Kim	3378247bee	prepare release	2018-07-11 13:27:50 +06:00
Nikolay Kim	7507412a1d	fix h2 compatibility	2018-07-11 13:26:51 +06:00
Nikolay Kim	6b9a193aa8	update changelog	2018-07-11 13:26:40 +06:00
Gary Hai	c2979760b5	Fix duplicate tail of StaticFiles with index_file. (#344 )	2018-06-25 19:37:24 +03:00
Nikolay Kim	1fcf1d4a49	prepare release	2018-06-21 09:47:46 +06:00
Nikolay Kim	4012606910	SendRequest execution fails with the entered unreachable code #329	2018-06-21 09:47:28 +06:00
Nikolay Kim	e975124630	Allow to disable masking for websockets client	2018-06-21 09:38:59 +06:00
Nikolay Kim	6862aa6ee7	prepare release	2018-06-13 05:04:59 -07:00
Nikolay Kim	8a22558f25	http/2 end-of-frame is not set if body is empty bytes #307	2018-06-12 14:47:45 -07:00
Nikolay Kim	b5b9f9656e	do not allow stream or actor responses for internal error #301	2018-06-11 19:44:11 -07:00
Nikolay Kim	2fffc55d34	update changelog	2018-06-11 18:53:36 -07:00
Nikolay Kim	7d39f1582e	InternalError can trigger memory unsafety #301	2018-06-11 18:52:54 -07:00
Nikolay Kim	75ed053a35	bump version	2018-06-11 12:32:31 -07:00
Nikolay Kim	cfedf5fff4	Merge branch '0.6' of github.com:actix/actix-web into 0.6	2018-06-11 12:32:05 -07:00
Nikolay Kim	be73a36339	use custom resolver	2018-06-11 12:28:43 -07:00
Nikolay Kim	1ad8ba2604	Fix docs.rs build	2018-06-11 12:25:20 -07:00
Armin Ronacher	6848a12095	prepare 0.6.12 release	2018-06-09 01:22:19 +02:00
Nikolay Kim	4797298706	Allow to use custom resolver for ClientConnector	2018-06-08 16:10:47 -07:00
Nikolay Kim	5eaf4cbefd	update changelog	2018-06-08 08:42:10 -07:00
Nikolay Kim	7f1844e541	fix doc test	2018-06-07 20:22:50 -07:00
Nikolay Kim	6c7ac7fc22	update changelog	2018-06-07 20:07:58 -07:00
Nikolay Kim	42f9e1034b	add Host predicate	2018-06-07 20:05:45 -07:00
Nikolay Kim	e3cd0fdd13	add application filters	2018-06-07 20:05:26 -07:00
Nikolay Kim	40ff550460	update changelog	2018-06-07 20:04:40 -07:00
Armin Ronacher	7119340d44	Added improved failure interoperability with downcasting (#285 ) Deprecates Error::cause and introduces failure interoperability functions and downcasting.	2018-06-07 20:03:10 -07:00
Nikolay Kim	e140bc3906	prep release	2018-06-05 09:44:29 -07:00
Nikolay Kim	fdc08d365d	metadata for docs.rs	2018-06-05 08:59:30 -07:00
Nikolay Kim	8f1b88e39e	update changelog	2018-06-05 08:53:27 -07:00
Nikolay Kim	6a40a0a466	fix multipart boundary parsing #282	2018-06-05 08:52:46 -07:00
Nikolay Kim	89fc6b6ac9	changelog	2018-06-05 07:42:52 -07:00
Nikolay Kim	afa67b838a	CORS: Do not validate Origin header on non-OPTION requests #271	2018-06-05 07:41:13 -07:00
Nikolay Kim	f7b7d282bf	Middleware::response is not invoked if error result was returned by another Middleware::start #255	2018-06-04 13:57:54 -07:00
Nikolay Kim	09780ea9f3	changelog updates	2018-06-02 15:03:34 -07:00
Nikolay Kim	a7dab950f3	Support chunked encoding for UrlEncoded body #262	2018-06-02 15:02:42 -07:00
Nikolay Kim	ec0737e392	fix doc test	2018-06-02 13:48:37 -07:00
Nikolay Kim	d664993d56	remove debug prints	2018-06-02 11:58:11 -07:00
Nikolay Kim	a9c6c57a67	remove debug print	2018-06-02 11:55:27 -07:00
Nikolay Kim	08e7374eee	update changelog	2018-06-02 11:46:53 -07:00
Nikolay Kim	42da1448fb	fixed HttpRequest::url_for for a named route with no variables #265	2018-06-02 11:46:02 -07:00
				`@@ -1 +0,0 @@`
				`<EFBFBD>TǑɂV<EFBFBD>2<EFBFBD>vI<EFBFBD><EFBFBD><EFBFBD>\<5C>R˙<52><CB99><EFBFBD>e<EFBFBD><04>vD<76>:藽<>RV<03>Yp<59><70>;<3B><>G<><47>p!2<7F>C<EFBFBD>.<2E><0C><><EFBFBD><EFBFBD>pA!<21>ߦ<EFBFBD>x j+Uc<55><63><EFBFBD>X<13>c%<17>;<3B>"y<10><>AI`