prepare actix-multipart release

actix-multipart: Fix multipart boundary reading (#1189 )
* actix-multipart: Fix multipart boundary reading If we're not ready to read the first line after the multipart field (which should be a "\r\n" line) then return NotReady instead of Ready(None) so that we will get called again to read that line. Without this I was getting MultipartError::Boundary from read_boundary() because it got the "\r\n" line instead of the boundary. * actix-multipart: Test handling of NotReady Use a stream that reports NoReady and does partial reads in the test_stream test. This works now, but failed before the previous commit.
2025-07-13 05:43:57 +02:00 · 2019-12-07 20:02:46 +06:00 · 2019-12-07 19:58:38 +06:00
217 changed files with 13837 additions and 14113 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,37 +0,0 @@
---
-name: bug report
-about: create a bug report
---
-
-Your issue may already be reported!
-Please search on the [Actix Web issue tracker](https://github.com/actix/actix-web/issues) before creating one.
-
-## Expected Behavior
-<!--- If you're describing a bug, tell us what should happen -->
-<!--- If you're suggesting a change/improvement, tell us how it should work -->
-
-## Current Behavior
-<!--- If describing a bug, tell us what happens instead of the expected behavior -->
-<!--- If suggesting a change/improvement, explain the difference from current behavior -->
-
-## Possible Solution
-<!--- Not obligatory, but suggest a fix/reason for the bug, -->
-<!--- or ideas how to implement the addition or change -->
-
-## Steps to Reproduce (for bugs)
-<!--- Provide a link to a live example, or an unambiguous set of steps to -->
-<!--- reproduce this bug. Include code to reproduce, if relevant -->
-1.
-2.
-3.
-4.
-
-## Context
-<!--- How has this issue affected you? What are you trying to accomplish? -->
-<!--- Providing context helps us come up with a solution that is most useful in the real world -->
-
-## Your Environment
-<!--- Include as many relevant details about the environment you experienced the bug in -->
-
-* Rust Version (I.e, output of `rustc -V`):
-* Actix Web Version:
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@ -1,8 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Gitter channel (actix-web)
-    url: https://gitter.im/actix/actix-web
-    about: Please ask and answer questions about the actix-web here.
-  - name: Gitter channel (actix)
-    url: https://gitter.im/actix/actix
-    about: Please ask and answer questions about the actix here.
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@ -1,23 +0,0 @@
-name: Benchmark (Linux)
-
-on: [push, pull_request]
-
-jobs:
-  check_benchmark:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          profile: minimal
-          override: true
-
-      - name: Check benchmark
-        uses: actions-rs/cargo@v1
-        with:
-          command: bench
-          args: --bench=server -- --sample-size=15
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@ -1,64 +0,0 @@
-name: CI (Linux)
-
-on: [push, pull_request]
-
-jobs:
-  build_and_test:
-    strategy:
-      fail-fast: false
-      matrix:
-        version:
-          - 1.40.0 # MSRV
-          - stable
-          - nightly
-
-    name: ${{ matrix.version }} - x86_64-unknown-linux-gnu
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Install ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: check build
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        timeout-minutes: 40
-        with:
-          command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
-
-      - name: tests (actix-http)
-        uses: actions-rs/cargo@v1
-        timeout-minutes: 40
-        with:
-          command: test
-          args: --package=actix-http --no-default-features --features=rustls -- --nocapture
-
-      - name: tests (awc)
-        uses: actions-rs/cargo@v1
-        timeout-minutes: 40
-        with:
-          command: test
-          args: --package=awc --no-default-features --features=rustls -- --nocapture
-
-      - name: Generate coverage file
-        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
-        run: |
-          cargo install cargo-tarpaulin
-          cargo tarpaulin --out Xml
-      - name: Upload to Codecov
-        if: matrix.version == 'stable' && (github.ref == 'refs/heads/master' || github.event_name == 'pull_request')
-        uses: codecov/codecov-action@v1
-        with:
-          file: cobertura.xml
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@ -1,39 +0,0 @@
-name: CI (macOS)
-
-on: [push, pull_request]
-
-jobs:
-  build_and_test:
-    strategy:
-      fail-fast: false
-      matrix:
-        version:
-          - stable
-          - nightly
-
-    name: ${{ matrix.version }} - x86_64-apple-darwin
-    runs-on: macOS-latest
-
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Install ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-x86_64-apple-darwin
-          profile: minimal
-          override: true
-
-      - name: check build
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
-                --skip=test_h2_content_length
-                --skip=test_reading_deflate_encoding_large_random_rustls
--- a/.github/workflows/upload-doc.yml
+++ b/.github/workflows/upload-doc.yml
@ -1,35 +0,0 @@
-name: Upload documentation
-
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    if: github.repository == 'actix/actix-web'
-
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable-x86_64-unknown-linux-gnu
-          profile: minimal
-          override: true
-
-      - name: check build
-        uses: actions-rs/cargo@v1
-        with:
-          command: doc
-          args: --no-deps --workspace --all-features
-
-      - name: Tweak HTML
-        run: echo "<meta http-equiv=refresh content=0;url=os_balloon/index.html>" > target/doc/index.html
-
-      - name: Upload documentation
-        run: |
-          git clone https://github.com/davisp/ghp-import.git
-          ./ghp-import/ghp_import.py -n -p -f -m "Documentation upload" -r https://${{ secrets.GITHUB_TOKEN }}@github.com/"${{ github.repository }}.git" target/doc
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@ -1,59 +0,0 @@
-name: CI (Windows)
-
-on: [push, pull_request]
-
-env:
-  VCPKGRS_DYNAMIC: 1
-
-jobs:
-  build_and_test:
-    strategy:
-      fail-fast: false
-      matrix:
-        version:
-          - stable
-          - nightly
-
-    name: ${{ matrix.version }} - x86_64-pc-windows-msvc
-    runs-on: windows-latest
-
-    steps:
-      - uses: actions/checkout@master
-
-      - name: Install ${{ matrix.version }}
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: ${{ matrix.version }}-x86_64-pc-windows-msvc
-          profile: minimal
-          override: true
-
-      - name: Install OpenSSL
-        run: |
-          vcpkg integrate install
-          vcpkg install openssl:x64-windows
-          Copy-Item C:\vcpkg\installed\x64-windows\bin\libcrypto-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libcrypto.dll
-          Copy-Item C:\vcpkg\installed\x64-windows\bin\libssl-1_1-x64.dll C:\vcpkg\installed\x64-windows\bin\libssl.dll
-          Get-ChildItem C:\vcpkg\installed\x64-windows\bin
-          Get-ChildItem C:\vcpkg\installed\x64-windows\lib
-
-      - name: check build
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --all --bins --examples --tests
-
-      - name: tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --all --all-features --no-fail-fast -- --nocapture
-                --skip=test_h2_content_length
-                --skip=test_reading_deflate_encoding_large_random_rustls
-                --skip=test_params
-                --skip=test_simple
-                --skip=test_expect_continue
-                --skip=test_http10_keepalive
-                --skip=test_slow_request
-                --skip=test_connection_force_close
-                --skip=test_connection_server_close
-                --skip=test_connection_wait_queue_force_close
--- a/.travis.yml
+++ b/.travis.yml
@ -0,0 +1,58 @@
+language: rust
+sudo: required
+dist: trusty
+
+cache:
+  # cargo: true
+  apt: true
+
+matrix:
+  include:
+    - rust: stable
+    - rust: beta
+    - rust: nightly-2019-08-10
+  allow_failures:
+    - rust: nightly-2019-08-10
+
+env:
+  global:
+    # - RUSTFLAGS="-C link-dead-code"
+    - OPENSSL_VERSION=openssl-1.0.2
+
+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
+
+# 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 ..
+
+# 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 &&
+      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,119 +1,5 @@
 # Changes

-## [3.0.0-alpha.3] - 2020-05-21
-
-### Added
-
-* Add option to create `Data<T>` from `Arc<T>` [#1509]
-
-### Changed
-
-* Resources and Scopes can now access non-overridden data types set on App (or containing scopes) when setting their own data. [#1486]
-
-* Fix audit issue logging by default peer address [#1485]
-
-* Bump minimum supported Rust version to 1.40
-
-* Replace deprecated `net2` crate with `socket2`
-
-[#1485]: https://github.com/actix/actix-web/pull/1485
-[#1509]: https://github.com/actix/actix-web/pull/1509
-
-## [3.0.0-alpha.2] - 2020-05-08
-
-### Changed
-
-* `{Resource,Scope}::default_service(f)` handlers now support app data extraction. [#1452]
-* Implement `std::error::Error` for our custom errors [#1422]
-* NormalizePath middleware now appends trailing / so that routes of form /example/ respond to /example requests. [#1433]
-* Remove the `failure` feature and support.
-
-[#1422]: https://github.com/actix/actix-web/pull/1422
-[#1433]: https://github.com/actix/actix-web/pull/1433
-[#1452]: https://github.com/actix/actix-web/pull/1452
-[#1486]: https://github.com/actix/actix-web/pull/1486
-
-
-## [3.0.0-alpha.1] - 2020-03-11
-
-### Added
-
-* Add helper function for creating routes with `TRACE` method guard `web::trace()`
-* Add convenience functions `test::read_body_json()` and `test::TestRequest::send_request()` for testing.
-
-### Changed
-
-* Use `sha-1` crate instead of unmaintained `sha1` crate
-* Skip empty chunks when returning response from a `Stream` [#1308]
-* Update the `time` dependency to 0.2.7
-* Update `actix-tls` dependency to 2.0.0-alpha.1
-* Update `rustls` dependency to 0.17
-
-[#1308]: https://github.com/actix/actix-web/pull/1308
-
-## [2.0.0] - 2019-12-25
-
-### Changed
-
-* Rename `HttpServer::start()` to `HttpServer::run()`
-
-* Allow to gracefully stop test server via `TestServer::stop()`
-
-* Allow to specify multi-patterns for resources
-
-## [2.0.0-rc] - 2019-12-20
-
-### Changed
-
-* Move `BodyEncoding` to `dev` module #1220
-
-* Allow to set `peer_addr` for TestRequest #1074
-
-* Make web::Data deref to Arc<T> #1214
-
-* Rename `App::register_data()` to `App::app_data()`
-
-* `HttpRequest::app_data<T>()` returns `Option<&T>` instead of `Option<&Data<T>>`
-
-### Fixed
-
-* Fix `AppConfig::secure()` is always false. #1202
-
-
-## [2.0.0-alpha.6] - 2019-12-15
-
-### Fixed
-
-* Fixed compilation with default features off
-
-## [2.0.0-alpha.5] - 2019-12-13
-
-### Added
-
-* Add test server, `test::start()` and `test::start_with()`
-
-## [2.0.0-alpha.4] - 2019-12-08
-
-### Deleted
-
-* Delete HttpServer::run(), it is not useful witht async/await
-
-## [2.0.0-alpha.3] - 2019-12-07
-
-### Changed
-
-* Migrate to tokio 0.2
-
-
-## [2.0.0-alpha.1] - 2019-11-22
-
-### Changed
-
-* Migrated to `std::future`
-
-* Remove implementation of `Responder` for `()`. (#1167)
-
-
 ## [1.0.9] - 2019-11-14

 ### Added
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "3.0.0-alpha.3"
+version = "1.0.9"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
@ -12,10 +12,11 @@ categories = ["network-programming", "asynchronous",
              "web-programming::http-server",
              "web-programming::websocket"]
 license = "MIT/Apache-2.0"
+exclude = [".gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 edition = "2018"

 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies"]
+features = ["ssl", "brotli", "flate2-zlib", "secure-cookies", "client", "rust-tls", "uds"]

 [badges]
 travis-ci = { repository = "actix/actix-web", branch = "master" }
@ -30,8 +31,11 @@ members = [
  ".",
  "awc",
  "actix-http",
+  "actix-cors",
  "actix-files",
  "actix-framed",
+  "actix-session",
+  "actix-identity",
  "actix-multipart",
  "actix-web-actors",
  "actix-web-codegen",
@ -39,77 +43,78 @@ members = [
 ]

 [features]
-default = ["compress"]
+default = ["brotli", "flate2-zlib", "client", "fail"]

-# content-encoding support
-compress = ["actix-http/compress", "awc/compress"]
+# 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"]
+
 # openssl
-openssl = ["actix-tls/openssl", "awc/openssl", "open-ssl"]
+ssl = ["openssl", "actix-server/ssl", "awc/ssl"]

 # rustls
-rustls = ["actix-tls/rustls", "awc/rustls", "rust-tls"]
+rust-tls = ["rustls", "actix-server/rust-tls", "awc/rust-tls"]

-[[example]]
-name = "basic"
-required-features = ["compress"]
-
-[[example]]
-name = "uds"
-required-features = ["compress"]
-
-[[test]]
-name = "test_server"
-required-features = ["compress"]
+# unix domain sockets support
+uds = ["actix-server/uds"]

 [dependencies]
-actix-codec = "0.2.0"
-actix-service = "1.0.2"
-actix-utils = "1.0.6"
-actix-router = "0.2.4"
-actix-rt = "1.0.0"
-actix-server = "1.0.0"
-actix-testing = "1.0.0"
-actix-macros = "0.1.0"
-actix-threadpool = "0.3.1"
-actix-tls = "2.0.0-alpha.1"
+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.11"
+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-web-codegen = "0.2.2"
-actix-http = "2.0.0-alpha.4"
-awc = { version = "2.0.0-alpha.2", default-features = false }
-
-bytes = "0.5.3"
-derive_more = "0.99.2"
+bytes = "0.4"
+derive_more = "0.15.0"
 encoding_rs = "0.8"
-futures-channel = { version = "0.3.5", default-features = false }
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false }
-fxhash = "0.2.1"
+futures = "0.1.25"
+hashbrown = "0.6.3"
 log = "0.4"
 mime = "0.3"
-socket2 = "0.3"
-pin-project = "0.4.6"
-regex = "1.3"
+net2 = "0.2.33"
+parking_lot = "0.9"
+regex = "1.0"
 serde = { version = "1.0", features=["derive"] }
 serde_json = "1.0"
 serde_urlencoded = "0.6.1"
-time = { version = "0.2.7", default-features = false, features = ["std"] }
+time = "0.1.42"
 url = "2.1"
-open-ssl = { version="0.10", package = "openssl", optional = true }
-rust-tls = { version = "0.17.0", package = "rustls", optional = true }
-tinyvec = { version = "0.3", features = ["alloc"] }
+
+# ssl support
+openssl = { version="0.10", optional = true }
+rustls = { version = "0.15", optional = true }

 [dev-dependencies]
-actix = "0.10.0-alpha.1"
+actix = "0.8.3"
+actix-connect = "0.2.2"
+actix-http-test = "0.2.4"
 rand = "0.7"
-env_logger = "0.7"
+env_logger = "0.6"
 serde_derive = "1.0"
+tokio-timer = "0.2.8"
 brotli2 = "0.3.2"
-flate2 = "1.0.13"
-criterion = "0.3"
+flate2 = "1.0.2"

 [profile.release]
 lto = true
@ -121,14 +126,8 @@ 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" }
-
-[[bench]]
-name = "server"
-harness = false
-
-[[bench]]
-name = "service"
-harness = false
--- a/MIGRATION.md
+++ b/MIGRATION.md
@ -1,65 +1,3 @@
-## Unreleased
-
-* Setting a cookie's SameSite property, explicitly, to `SameSite::None` will now
-  result in `SameSite=None` being sent with the response Set-Cookie header.
-  To create a cookie without a SameSite attribute, remove any calls setting same_site.
-
-* actix-http support for Actors messages was moved to actix-http crate and is enabled 
-  with feature `actors`
-* content_length function is removed from actix-http.
-  You can set Content-Length by normally setting the response body or calling no_chunking function. 
-
-* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
-  `u64` instead of a `usize`.
-
-## 2.0.0
-
-* `HttpServer::start()` renamed to `HttpServer::run()`. It also possible to
-  `.await` on `run` method result, in that case it awaits server exit.
-
-* `App::register_data()` renamed to `App::app_data()` and accepts any type `T: 'static`.
-  Stored data is available via `HttpRequest::app_data()` method at runtime.
-
-* Extractor configuration must be registered with `App::app_data()` instead of `App::data()`
-
-* Sync handlers has been removed. `.to_async()` method has been renamed to `.to()`
-  replace `fn` with `async fn` to convert sync handler to async
-
-* `actix_http_test::TestServer` moved to `actix_web::test` module. To start
-  test server use `test::start()` or `test_start_with_config()` methods
-
-* `ResponseError` trait has been reafctored. `ResponseError::error_response()` renders
-  http response.
-
-* Feature `rust-tls` renamed to `rustls`
-
-  instead of
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["rust-tls"] }
-    ```
-
-  use
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["rustls"] }
-    ```
-
-* Feature `ssl` renamed to `openssl`
-
-  instead of
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["ssl"] }
-    ```
-
-  use
-
-    ```rust
-    actix-web = { version = "2.0.0", features = ["openssl"] }
-    ```
-* `Cors` builder now requires that you call `.finish()` to construct the middleware
-
 ## 1.0.1

 * Cors middleware has been moved to `actix-cors` crate
@ -96,52 +34,52 @@
 * 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 {
@ -150,7 +88,7 @@
         .route(post().to(handler_fn)),
  )
  ```
-
+  
 * Resource registration. 1.0 version uses generalized resource
  registration via `.service()` method.

@ -366,7 +304,7 @@

 * `actix_web::server` module has been removed. To start http server use `actix_web::HttpServer` type

-* StaticFiles and NamedFile have been moved to a separate crate.
+* StaticFiles and NamedFile has been move to separate create.

  instead of `use actix_web::fs::StaticFile`

@ -376,7 +314,7 @@

  use `use actix_files::NamedFile`

-* Multipart has been moved to a separate crate.
+* Multipart has been move to separate create.

  instead of `use actix_web::multipart::Multipart`

@ -441,9 +379,9 @@

 * `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
@ -469,8 +407,8 @@
  trait uses `&HttpRequest` instead of `&mut HttpRequest`.

 * Removed `Route::with2()` and `Route::with3()` use tuple of extractors instead.
-
-    instead of
+    
+    instead of 

    ```rust
    fn index(query: Query<..>, info: Json<MyStruct) -> impl Responder {}
@ -486,7 +424,7 @@

 * `Handler::handle()` accepts reference to `HttpRequest<_>` instead of value

-* Removed deprecated `HttpServer::threads()`, use
+* 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
@ -495,7 +433,7 @@
 * `Route::with()` does not return `ExtractorConfig`, to configure
  extractor use `Route::with_config()`

-    instead of
+    instead of 

    ```rust
    fn main() {
@ -506,11 +444,11 @@
         });
    }
    ```
-
-    use
-
+    
+    use 
+    
    ```rust
-
+  
    fn main() {
         let app = App::new().resource("/index.html", |r| {
             r.method(http::Method::GET)
@ -540,12 +478,12 @@
 * `HttpRequest::extensions()` returns read only reference to the request's Extension
  `HttpRequest::extensions_mut()` returns mutable reference.

-* Instead of
+* Instead of 

   `use actix_web::middleware::{
        CookieSessionBackend, CookieSessionError, RequestSession,
        Session, SessionBackend, SessionImpl, SessionStorage};`
-
+                                
  use `actix_web::middleware::session`

   `use actix_web::middleware::session{CookieSessionBackend, CookieSessionError,
--- a/README.md
+++ b/README.md
@ -1,28 +1,4 @@
-<div align="center">
- <p><h1>Actix web</h1> </p>
-  <p><strong>Actix web is a small, pragmatic, and extremely fast rust web framework</strong> </p>
-  <p>
-
-[![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)
-[![Documentation](https://docs.rs/actix-web/badge.svg)](https://docs.rs/actix-web)
-[![Download](https://img.shields.io/crates/d/actix-web.svg)](https://crates.io/crates/actix-web)
-[![Version](https://img.shields.io/badge/rustc-1.40+-lightgray.svg)](https://blog.rust-lang.org/2019/12/19/Rust-1.40.0.html)
-![License](https://img.shields.io/crates/l/actix-web.svg)
-
-  </p>
-
-  <h3>
-    <a href="https://actix.rs">Website</a>
-    <span> | </span>
-    <a href="https://gitter.im/actix/actix">Chat</a>
-    <span> | </span>
-    <a href="https://github.com/actix/examples">Examples</a>
-  </h3>
-</div>
-<br>
+# 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 is a simple, pragmatic and extremely fast web framework for Rust.

@ -38,40 +14,31 @@ Actix web is a simple, pragmatic and extremely fast web framework for Rust.
 * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
 * Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
 * Supports [Actix actor framework](https://github.com/actix/actix)
-* Supports Rust 1.40+

-## Docs
+## Documentation & community resources

-* [API documentation (master)](https://actix.rs/actix-web/actix_web)
-* [API documentation (docs.rs)](https://docs.rs/actix-web)
-* [User guide](https://actix.rs)
+* [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/)
+* [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

 ## Example

-Dependencies:
-
-```toml
-[dependencies]
-actix-web = "2"
-actix-rt = "1"
-```
-
-Code:
-
 ```rust
-use actix_web::{get, web, App, HttpServer, Responder};
+use actix_web::{web, App, HttpServer, Responder};

-#[get("/{id}/{name}/index.html")]
-async fn index(info: web::Path<(u32, String)>) -> impl Responder {
+fn index(info: web::Path<(u32, String)>) -> impl Responder {
    format!("Hello {}! id:{}", info.1, info.0)
 }

-#[actix_rt::main]
-async fn main() -> std::io::Result<()> {
-    HttpServer::new(|| App::new().service(index))
+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()
-        .await
 }
 ```

@ -81,12 +48,11 @@ async fn main() -> std::io::Result<()> {
 * [Stateful](https://github.com/actix/examples/tree/master/state/)
 * [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/)
-* [Askama](https://github.com/actix/examples/tree/master/template_askama/) templates
+* [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/)
-* [OpenSSL](https://github.com/actix/examples/tree/master/openssl/)
-* [Rustls](https://github.com/actix/examples/tree/master/rustls/)
+* [SSL / HTTP/2.0](https://github.com/actix/examples/tree/master/tls/)
 * [Tcp/Websocket chat](https://github.com/actix/examples/tree/master/websocket-chat/)
 * [Json](https://github.com/actix/examples/tree/master/json/)

--- a/actix-cors/CHANGES.md
+++ b/actix-cors/CHANGES.md
@ -0,0 +1,9 @@
+# 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
@ -0,0 +1,23 @@
+[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
@ -0,0 +1 @@
+../LICENSE-APACHE
--- a/actix-cors/LICENSE-MIT
+++ b/actix-cors/LICENSE-MIT
@ -0,0 +1 @@
+../LICENSE-MIT
--- a/actix-cors/README.md
+++ b/actix-cors/README.md
@ -1,7 +1,5 @@
 # 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)

-**This crate moved to https://github.com/actix/actix-extras.**
-
 ## Documentation & community resources

 * [User Guide](https://actix.rs/docs/)
--- a/actix-cors/src/lib.rs
+++ b/actix-cors/src/lib.rs
--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@ -1,26 +1,5 @@
 # Changes

-## [0.3.0-alpha.1] - 2020-05-23
-
-* Update `actix-web` and `actix-http` dependencies to alpha
-* Fix some typos in the docs
-* Bump minimum supported Rust version to 1.40
-* Support sending Content-Length when Content-Range is specified [#1384]
-
-[#1384]: https://github.com/actix/actix-web/pull/1384
-
-## [0.2.1] - 2019-12-22
-
-* Use the same format for file URLs regardless of platforms
-
-## [0.2.0] - 2019-12-20
-
-* Fix BodyEncoding trait import #1220
-
-## [0.2.0-alpha.1] - 2019-12-07
-
-* Migrate to `std::future`
-
 ## [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)
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-files"
-version = "0.3.0-alpha.1"
+version = "0.1.7"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static files support for actix web."
 readme = "README.md"
@ -18,14 +18,13 @@ name = "actix_files"
 path = "src/lib.rs"

 [dependencies]
-actix-web = { version = "3.0.0-alpha.3", default-features = false }
-actix-http = "2.0.0-alpha.4"
-actix-service = "1.0.1"
+actix-web = { version = "1.0.8", default-features = false }
+actix-http = "0.2.11"
+actix-service = "0.4.1"
 bitflags = "1"
-bytes = "0.5.3"
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false }
-derive_more = "0.99.2"
+bytes = "0.4"
+futures = "0.1.25"
+derive_more = "0.15.0"
 log = "0.4"
 mime = "0.3"
 mime_guess = "2.0.1"
@ -33,5 +32,4 @@ percent-encoding = "2.1"
 v_htmlescape = "0.4"

 [dev-dependencies]
-actix-rt = "1.0.0"
-actix-web = { version = "3.0.0-alpha.3", features = ["openssl"] }
+actix-web = { version = "1.0.8", features=["ssl"] }
--- a/actix-files/README.md
+++ b/actix-files/README.md
@ -6,4 +6,4 @@
 * [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.40 or later
+* Minimum supported Rust version: 1.33 or later
--- a/actix-files/src/error.rs
+++ b/actix-files/src/error.rs
@ -5,7 +5,6 @@ use derive_more::Display;
 #[derive(Display, Debug, PartialEq)]
 pub enum FilesError {
    /// Path is not a directory
-    #[allow(dead_code)]
    #[display(fmt = "Path is not a directory. Unable to serve static files")]
    IsNotDirectory,

@ -36,7 +35,7 @@ pub enum UriSegmentError {

 /// Return `BadRequest` for `UriSegmentError`
 impl ResponseError for UriSegmentError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+    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
@ -12,13 +12,12 @@ use mime;
 use mime_guess::from_path;

 use actix_http::body::SizedStream;
-use actix_web::dev::BodyEncoding;
 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 futures_util::future::{ready, Ready};

 use crate::range::HttpRange;
 use crate::ChunkedReadFile;
@ -256,8 +255,62 @@ impl NamedFile {
    pub(crate) fn last_modified(&self) -> Option<header::HttpDate> {
        self.modified.map(|mtime| mtime.into())
    }
+}

-    pub fn into_response(self, req: &HttpRequest) -> Result<HttpResponse, Error> {
+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()))
@ -388,69 +441,9 @@ impl NamedFile {
            fut: None,
            counter: 0,
        };
-
        if offset != 0 || length != self.md.len() {
-            resp.status(StatusCode::PARTIAL_CONTENT);
-        }
-
+            return Ok(resp.status(StatusCode::PARTIAL_CONTENT).streaming(reader));
+        };
        Ok(resp.body(SizedStream::new(length, reader)))
    }
 }
-
-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 = Ready<Result<HttpResponse, Error>>;
-
-    fn respond_to(self, req: &HttpRequest) -> Self::Future {
-        ready(self.into_response(req))
-    }
-}
--- a/actix-framed/Cargo.toml
+++ b/actix-framed/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-framed"
-version = "0.3.0"
+version = "0.2.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix framed app server"
 readme = "README.md"
@ -13,25 +13,26 @@ categories = ["network-programming", "asynchronous",
              "web-programming::websocket"]
 license = "MIT/Apache-2.0"
 edition = "2018"
+workspace =".."

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

 [dependencies]
-actix-codec = "0.2.0"
-actix-service = "1.0.1"
-actix-router = "0.2.1"
-actix-rt = "1.0.0"
-actix-http = "2.0.0-alpha.4"
+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.5.3"
-futures-util = { version = "0.3.5", default-features = false }
-pin-project = "0.4.6"
+bytes = "0.4"
+futures = "0.1.25"
 log = "0.4"

 [dev-dependencies]
-actix-server = "1.0.0"
-actix-connect = { version = "2.0.0-alpha.2", features = ["openssl"] }
-actix-http-test = { version = "2.0.0-alpha.1", features = ["openssl"] }
-actix-utils = "1.0.3"
+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/README.md
+++ b/actix-framed/README.md
@ -5,4 +5,4 @@
 * [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.40 or later
+* Minimum supported Rust version: 1.33 or later
--- a/actix-framed/changes.md
+++ b/actix-framed/changes.md
@ -1,13 +1,5 @@
 # Changes

-## [Unreleased] - 2020-xx-xx
-
-* Bump minimum supported Rust version to 1.40
-
-## [0.3.0] - 2019-12-25
-
-* Migrate to actix-http 1.0
-
 ## [0.2.1] - 2019-07-20

 * Remove unneeded actix-utils dependency
--- a/actix-framed/src/app.rs
+++ b/actix-framed/src/app.rs
@ -1,23 +1,21 @@
-use std::future::Future;
-use std::pin::Pin;
 use std::rc::Rc;
-use std::task::{Context, Poll};

 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_service::{IntoServiceFactory, Service, ServiceFactory};
-use futures_util::future::{ok, FutureExt, LocalBoxFuture};
+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 = LocalBoxFuture<'static, Result<(), Error>>;
+type BoxedResponse = Box<dyn Future<Item = (), Error = Error>>;

 pub trait HttpServiceFactory {
-    type Factory: ServiceFactory;
+    type Factory: NewService;

    fn path(&self) -> &str;

@ -50,19 +48,19 @@ impl<T: 'static, S: 'static> FramedApp<T, S> {
    pub fn service<U>(mut self, factory: U) -> Self
    where
        U: HttpServiceFactory,
-        U::Factory: ServiceFactory<
+        U::Factory: NewService<
                Config = (),
                Request = FramedRequest<T, S>,
                Response = (),
                Error = Error,
                InitError = (),
            > + 'static,
-        <U::Factory as ServiceFactory>::Future: 'static,
-        <U::Factory as ServiceFactory>::Service: Service<
+        <U::Factory as NewService>::Future: 'static,
+        <U::Factory as NewService>::Service: Service<
            Request = FramedRequest<T, S>,
            Response = (),
            Error = Error,
-            Future = LocalBoxFuture<'static, Result<(), Error>>,
+            Future = Box<dyn Future<Item = (), Error = Error>>,
        >,
    {
        let path = factory.path().to_string();
@ -72,12 +70,12 @@ impl<T: 'static, S: 'static> FramedApp<T, S> {
    }
 }

-impl<T, S> IntoServiceFactory<FramedAppFactory<T, S>> for FramedApp<T, S>
+impl<T, S> IntoNewService<FramedAppFactory<T, S>> for FramedApp<T, S>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
    S: 'static,
 {
-    fn into_factory(self) -> FramedAppFactory<T, S> {
+    fn into_new_service(self) -> FramedAppFactory<T, S> {
        FramedAppFactory {
            state: self.state,
            services: Rc::new(self.services),
@ -91,12 +89,12 @@ pub struct FramedAppFactory<T, S> {
    services: Rc<Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>>,
 }

-impl<T, S> ServiceFactory for FramedAppFactory<T, S>
+impl<T, S> NewService for FramedAppFactory<T, S>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
    S: 'static,
 {
-    type Config = ();
+    type Config = ServerConfig;
    type Request = (Request, Framed<T, Codec>);
    type Response = ();
    type Error = Error;
@ -104,7 +102,7 @@ where
    type Service = FramedAppService<T, S>;
    type Future = CreateService<T, S>;

-    fn new_service(&self, _: ()) -> Self::Future {
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
        CreateService {
            fut: self
                .services
@ -112,7 +110,7 @@ where
                .map(|(path, service)| {
                    CreateServiceItem::Future(
                        Some(path.clone()),
-                        service.new_service(()),
+                        service.new_service(&()),
                    )
                })
                .collect(),
@ -130,30 +128,28 @@ pub struct CreateService<T, S> {
 enum CreateServiceItem<T, S> {
    Future(
        Option<String>,
-        LocalBoxFuture<'static, Result<BoxedHttpService<FramedRequest<T, S>>, ()>>,
+        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 + Unpin,
+    T: AsyncRead + AsyncWrite,
 {
-    type Output = Result<FramedAppService<T, S>, ()>;
+    type Item = FramedAppService<T, S>;
+    type Error = ();

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    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 Pin::new(fut).poll(cx) {
-                        Poll::Ready(Ok(service)) => {
-                            Some((path.take().unwrap(), service))
-                        }
-                        Poll::Ready(Err(e)) => return Poll::Ready(Err(e)),
-                        Poll::Pending => {
+                    match fut.poll()? {
+                        Async::Ready(service) => Some((path.take().unwrap(), service)),
+                        Async::NotReady => {
                            done = false;
                            None
                        }
@ -180,12 +176,12 @@ where
                    }
                    router
                });
-            Poll::Ready(Ok(FramedAppService {
+            Ok(Async::Ready(FramedAppService {
                router: router.finish(),
                state: self.state.clone(),
            }))
        } else {
-            Poll::Pending
+            Ok(Async::NotReady)
        }
    }
 }
@ -197,15 +193,15 @@ pub struct FramedAppService<T, S> {

 impl<S: 'static, T: 'static> Service for FramedAppService<T, S>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: AsyncRead + AsyncWrite,
 {
    type Request = (Request, Framed<T, Codec>);
    type Response = ();
    type Error = Error;
    type Future = BoxedResponse;

-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
    }

    fn call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
@ -214,8 +210,8 @@ where
        if let Some((srv, _info)) = self.router.recognize_mut(&mut path) {
            return srv.call(FramedRequest::new(req, framed, path, self.state.clone()));
        }
-        SendResponse::new(framed, Response::NotFound().finish())
-            .then(|_| ok(()))
-            .boxed_local()
+        Box::new(
+            SendResponse::new(framed, Response::NotFound().finish()).then(|_| Ok(())),
+        )
    }
 }
--- a/actix-framed/src/helpers.rs
+++ b/actix-framed/src/helpers.rs
@ -1,38 +1,36 @@
-use std::task::{Context, Poll};
-
 use actix_http::Error;
-use actix_service::{Service, ServiceFactory};
-use futures_util::future::{FutureExt, LocalBoxFuture};
+use actix_service::{NewService, Service};
+use futures::{Future, Poll};

 pub(crate) type BoxedHttpService<Req> = Box<
    dyn Service<
        Request = Req,
        Response = (),
        Error = Error,
-        Future = LocalBoxFuture<'static, Result<(), Error>>,
+        Future = Box<dyn Future<Item = (), Error = Error>>,
    >,
 >;

 pub(crate) type BoxedHttpNewService<Req> = Box<
-    dyn ServiceFactory<
+    dyn NewService<
        Config = (),
        Request = Req,
        Response = (),
        Error = Error,
        InitError = (),
        Service = BoxedHttpService<Req>,
-        Future = LocalBoxFuture<'static, Result<BoxedHttpService<Req>, ()>>,
+        Future = Box<dyn Future<Item = BoxedHttpService<Req>, Error = ()>>,
    >,
 >;

-pub(crate) struct HttpNewService<T: ServiceFactory>(T);
+pub(crate) struct HttpNewService<T: NewService>(T);

 impl<T> HttpNewService<T>
 where
-    T: ServiceFactory<Response = (), Error = Error>,
+    T: NewService<Response = (), Error = Error>,
    T::Response: 'static,
    T::Future: 'static,
-    T::Service: Service<Future = LocalBoxFuture<'static, Result<(), Error>>> + 'static,
+    T::Service: Service<Future = Box<dyn Future<Item = (), Error = Error>>> + 'static,
    <T::Service as Service>::Future: 'static,
 {
    pub fn new(service: T) -> Self {
@ -40,12 +38,12 @@ where
    }
 }

-impl<T> ServiceFactory for HttpNewService<T>
+impl<T> NewService for HttpNewService<T>
 where
-    T: ServiceFactory<Config = (), Response = (), Error = Error>,
+    T: NewService<Config = (), Response = (), Error = Error>,
    T::Request: 'static,
    T::Future: 'static,
-    T::Service: Service<Future = LocalBoxFuture<'static, Result<(), Error>>> + 'static,
+    T::Service: Service<Future = Box<dyn Future<Item = (), Error = Error>>> + 'static,
    <T::Service as Service>::Future: 'static,
 {
    type Config = ();
@ -54,19 +52,13 @@ where
    type Error = Error;
    type InitError = ();
    type Service = BoxedHttpService<T::Request>;
-    type Future = LocalBoxFuture<'static, Result<Self::Service, ()>>;
+    type Future = Box<dyn Future<Item = Self::Service, Error = ()>>;

-    fn new_service(&self, _: ()) -> Self::Future {
-        let fut = self.0.new_service(());
-
-        async move {
-            fut.await.map_err(|_| ()).map(|service| {
-                let service: BoxedHttpService<_> =
-                    Box::new(HttpServiceWrapper { service });
-                service
-            })
-        }
-        .boxed_local()
+    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)
+        }))
    }
 }

@ -78,7 +70,7 @@ impl<T> Service for HttpServiceWrapper<T>
 where
    T: Service<
        Response = (),
-        Future = LocalBoxFuture<'static, Result<(), Error>>,
+        Future = Box<dyn Future<Item = (), Error = Error>>,
        Error = Error,
    >,
    T::Request: 'static,
@ -86,10 +78,10 @@ where
    type Request = T::Request;
    type Response = ();
    type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<(), Error>>;
+    type Future = Box<dyn Future<Item = (), Error = Error>>;

-    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
-        self.service.poll_ready(cx)
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.service.poll_ready()
    }

    fn call(&mut self, req: Self::Request) -> Self::Future {
--- a/actix-framed/src/lib.rs
+++ b/actix-framed/src/lib.rs
@ -7,7 +7,7 @@ mod service;
 mod state;
 pub mod test;

-// re-export for convenience
+// re-export for convinience
 pub use actix_http::{http, Error, HttpMessage, Response, ResponseError};

 pub use self::app::{FramedApp, FramedAppService};
--- a/actix-framed/src/request.rs
+++ b/actix-framed/src/request.rs
@ -42,7 +42,7 @@ impl<Io, S> FramedRequest<Io, S> {
        self.req.head()
    }

-    /// This method returns mutable reference to the request 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 {
@ -123,15 +123,13 @@ impl<Io, S> FramedRequest<Io, S> {

 #[cfg(test)]
 mod tests {
-    use std::convert::TryFrom;
-
-    use actix_http::http::{HeaderName, HeaderValue};
+    use actix_http::http::{HeaderName, HeaderValue, HttpTryFrom};
    use actix_http::test::{TestBuffer, TestRequest};

    use super::*;

    #[test]
-    fn test_request() {
+    fn test_reqest() {
        let buf = TestBuffer::empty();
        let framed = Framed::new(buf, Codec::default());
        let req = TestRequest::with_uri("/index.html?q=1")
--- a/actix-framed/src/route.rs
+++ b/actix-framed/src/route.rs
@ -1,12 +1,11 @@
 use std::fmt;
-use std::future::Future;
 use std::marker::PhantomData;
-use std::task::{Context, Poll};

 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_http::{http::Method, Error};
-use actix_service::{Service, ServiceFactory};
-use futures_util::future::{ok, FutureExt, LocalBoxFuture, Ready};
+use actix_service::{NewService, Service};
+use futures::future::{ok, FutureResult};
+use futures::{Async, Future, IntoFuture, Poll};
 use log::error;

 use crate::app::HttpServiceFactory;
@ -16,11 +15,11 @@ use crate::request::FramedRequest;
 ///
 /// 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 = (), E = ()> {
+pub struct FramedRoute<Io, S, F = (), R = ()> {
    handler: F,
    pattern: String,
    methods: Vec<Method>,
-    state: PhantomData<(Io, S, R, E)>,
+    state: PhantomData<(Io, S, R)>,
 }

 impl<Io, S> FramedRoute<Io, S> {
@ -54,12 +53,12 @@ impl<Io, S> FramedRoute<Io, S> {
        self
    }

-    pub fn to<F, R, E>(self, handler: F) -> FramedRoute<Io, S, F, R, E>
+    pub fn to<F, R>(self, handler: F) -> FramedRoute<Io, S, F, R>
    where
        F: FnMut(FramedRequest<Io, S>) -> R,
-        R: Future<Output = Result<(), E>> + 'static,
-
-        E: fmt::Debug,
+        R: IntoFuture<Item = ()>,
+        R::Future: 'static,
+        R::Error: fmt::Debug,
    {
        FramedRoute {
            handler,
@ -70,14 +69,15 @@ impl<Io, S> FramedRoute<Io, S> {
    }
 }

-impl<Io, S, F, R, E> HttpServiceFactory for FramedRoute<Io, S, F, R, E>
+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: Future<Output = Result<(), E>> + 'static,
-    E: fmt::Display,
+    R: IntoFuture<Item = ()>,
+    R::Future: 'static,
+    R::Error: fmt::Display,
 {
-    type Factory = FramedRouteFactory<Io, S, F, R, E>;
+    type Factory = FramedRouteFactory<Io, S, F, R>;

    fn path(&self) -> &str {
        &self.pattern
@ -92,28 +92,29 @@ where
    }
 }

-pub struct FramedRouteFactory<Io, S, F, R, E> {
+pub struct FramedRouteFactory<Io, S, F, R> {
    handler: F,
    methods: Vec<Method>,
-    _t: PhantomData<(Io, S, R, E)>,
+    _t: PhantomData<(Io, S, R)>,
 }

-impl<Io, S, F, R, E> ServiceFactory for FramedRouteFactory<Io, S, F, R, E>
+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: Future<Output = Result<(), E>> + 'static,
-    E: fmt::Display,
+    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, E>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Service = FramedRouteService<Io, S, F, R>;
+    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: ()) -> Self::Future {
+    fn new_service(&self, _: &()) -> Self::Future {
        ok(FramedRouteService {
            handler: self.handler.clone(),
            methods: self.methods.clone(),
@ -122,38 +123,35 @@ where
    }
 }

-pub struct FramedRouteService<Io, S, F, R, E> {
+pub struct FramedRouteService<Io, S, F, R> {
    handler: F,
    methods: Vec<Method>,
-    _t: PhantomData<(Io, S, R, E)>,
+    _t: PhantomData<(Io, S, R)>,
 }

-impl<Io, S, F, R, E> Service for FramedRouteService<Io, S, F, R, E>
+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: Future<Output = Result<(), E>> + 'static,
-    E: fmt::Display,
+    R: IntoFuture<Item = ()>,
+    R::Future: 'static,
+    R::Error: fmt::Display,
 {
    type Request = FramedRequest<Io, S>;
    type Response = ();
    type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<(), Error>>;
+    type Future = Box<dyn Future<Item = (), Error = Error>>;

-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
    }

    fn call(&mut self, req: FramedRequest<Io, S>) -> Self::Future {
-        let fut = (self.handler)(req);
-
-        async move {
-            let res = fut.await;
+        Box::new((self.handler)(req).into_future().then(|res| {
            if let Err(e) = res {
                error!("Error in request handler: {}", e);
            }
            Ok(())
-        }
-        .boxed_local()
+        }))
    }
 }
--- a/actix-framed/src/service.rs
+++ b/actix-framed/src/service.rs
@ -1,7 +1,4 @@
-use std::future::Future;
 use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use actix_http::body::BodySize;
@ -9,8 +6,9 @@ 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::{Service, ServiceFactory};
-use futures_util::future::{err, ok, Either, Ready};
+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`
@ -24,16 +22,16 @@ impl<T, C> Default for VerifyWebSockets<T, C> {
    }
 }

-impl<T, C> ServiceFactory for VerifyWebSockets<T, C> {
+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 = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: C) -> Self::Future {
+    fn new_service(&self, _: &C) -> Self::Future {
        ok(VerifyWebSockets { _t: PhantomData })
    }
 }
@ -42,16 +40,16 @@ 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 = Ready<Result<Self::Response, Self::Error>>;
+    type Future = FutureResult<Self::Response, Self::Error>;

-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+    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)),
-            Ok(_) => ok((req, framed)),
+            Err(e) => Err((e, framed)).into_future(),
+            Ok(_) => Ok((req, framed)).into_future(),
        }
    }
 }
@ -69,9 +67,9 @@ where
    }
 }

-impl<T, R, E, C> ServiceFactory for SendError<T, R, E, C>
+impl<T, R, E, C> NewService for SendError<T, R, E, C>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
    R: 'static,
    E: ResponseError + 'static,
 {
@ -81,34 +79,34 @@ where
    type Error = (E, Framed<T, Codec>);
    type InitError = ();
    type Service = SendError<T, R, E, C>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: C) -> Self::Future {
+    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 + Unpin + 'static,
+    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<Ready<Result<R, (E, Framed<T, Codec>)>>, SendErrorFut<T, R, E>>;
+    type Future = Either<FutureResult<R, (E, Framed<T, Codec>)>, SendErrorFut<T, R, E>>;

-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+    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::Left(ok(r)),
+            Ok(r) => Either::A(ok(r)),
            Err((e, framed)) => {
                let res = e.error_response().drop_body();
-                Either::Right(SendErrorFut {
+                Either::B(SendErrorFut {
                    framed: Some(framed),
                    res: Some((res, BodySize::Empty).into()),
                    err: Some(e),
@ -119,7 +117,6 @@ where
    }
 }

-#[pin_project::pin_project]
 pub struct SendErrorFut<T, R, E> {
    res: Option<Message<(Response<()>, BodySize)>>,
    framed: Option<Framed<T, Codec>>,
@ -130,27 +127,23 @@ pub struct SendErrorFut<T, R, E> {
 impl<T, R, E> Future for SendErrorFut<T, R, E>
 where
    E: ResponseError,
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: AsyncRead + AsyncWrite,
 {
-    type Output = Result<R, (E, Framed<T, Codec>)>;
+    type Item = R;
+    type Error = (E, Framed<T, Codec>);

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        if let Some(res) = self.res.take() {
-            if self.framed.as_mut().unwrap().write(res).is_err() {
-                return Poll::Ready(Err((
-                    self.err.take().unwrap(),
-                    self.framed.take().unwrap(),
-                )));
+            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().flush(cx) {
-            Poll::Ready(Ok(_)) => {
-                Poll::Ready(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()))
            }
-            Poll::Ready(Err(_)) => {
-                Poll::Ready(Err((self.err.take().unwrap(), self.framed.take().unwrap())))
-            }
-            Poll::Pending => Poll::Pending,
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Err(_) => Err((self.err.take().unwrap(), self.framed.take().unwrap())),
        }
    }
 }
--- a/actix-framed/src/test.rs
+++ b/actix-framed/src/test.rs
@ -1,13 +1,12 @@
 //! Various helpers for Actix applications to use during testing.
-use std::convert::TryFrom;
-use std::future::Future;
-
 use actix_codec::Framed;
 use actix_http::h1::Codec;
 use actix_http::http::header::{Header, HeaderName, IntoHeaderValue};
-use actix_http::http::{Error as HttpError, Method, Uri, Version};
+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};

@ -42,8 +41,7 @@ impl TestRequest<()> {
    /// Create TestRequest and set header
    pub fn with_header<K, V>(key: K, value: V) -> Self
    where
-        HeaderName: TryFrom<K>,
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
+        HeaderName: HttpTryFrom<K>,
        V: IntoHeaderValue,
    {
        Self::default().header(key, value)
@ -98,8 +96,7 @@ impl<S> TestRequest<S> {
    /// Set a header
    pub fn header<K, V>(mut self, key: K, value: V) -> Self
    where
-        HeaderName: TryFrom<K>,
-        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
+        HeaderName: HttpTryFrom<K>,
        V: IntoHeaderValue,
    {
        self.req.header(key, value);
@ -121,12 +118,13 @@ impl<S> TestRequest<S> {
    }

    /// This method generates `FramedRequest` instance and executes async handler
-    pub async fn run<F, R, I, E>(self, f: F) -> Result<I, E>
+    pub fn run<F, R, I, E>(self, f: F) -> Result<I, E>
    where
        F: FnOnce(FramedRequest<TestBuffer, S>) -> R,
-        R: Future<Output = Result<I, E>>,
+        R: IntoFuture<Item = I, Error = E>,
    {
-        f(self.finish()).await
+        let mut rt = Runtime::new().unwrap();
+        rt.block_on(f(self.finish()).into_future())
    }
 }

--- a/actix-framed/tests/test_server.rs
+++ b/actix-framed/tests/test_server.rs
@ -1,161 +1,141 @@
 use actix_codec::{AsyncRead, AsyncWrite};
 use actix_http::{body, http::StatusCode, ws, Error, HttpService, Response};
-use actix_http_test::test_server;
-use actix_service::{pipeline_factory, IntoServiceFactory, ServiceFactory};
-use actix_utils::framed::Dispatcher;
-use bytes::Bytes;
-use futures_util::{future, SinkExt, StreamExt};
+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};

-async fn ws_service<T: AsyncRead + AsyncWrite>(
+fn ws_service<T: AsyncRead + AsyncWrite>(
    req: FramedRequest<T>,
-) -> Result<(), Error> {
-    let (req, mut framed, _) = req.into_parts();
+) -> 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())
-        .await
-        .unwrap();
-    Dispatcher::new(framed.into_framed(ws::Codec::new()), service)
-        .await
-        .unwrap();
-
-    Ok(())
+        .map_err(|_| panic!())
+        .and_then(|framed| {
+            FramedTransport::new(framed.into_framed(ws::Codec::new()), service)
+                .map_err(|_| panic!())
+        })
 }

-async fn service(msg: ws::Frame) -> Result<ws::Message, Error> {
+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).to_string())
+            ws::Message::Text(String::from_utf8_lossy(&text.unwrap()).to_string())
        }
-        ws::Frame::Binary(bin) => ws::Message::Binary(bin),
+        ws::Frame::Binary(bin) => ws::Message::Binary(bin.unwrap().freeze()),
        ws::Frame::Close(reason) => ws::Message::Close(reason),
        _ => panic!(),
    };
-    Ok(msg)
+    ok(msg)
 }

-#[actix_rt::test]
-async fn test_simple() {
-    let mut srv = test_server(|| {
+#[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()))
-            .tcp()
-    })
-    .await;
+    });

-    assert!(srv.ws_at("/test").await.is_err());
+    assert!(srv.ws_at("/test").is_err());

    // client service
-    let mut framed = srv.ws_at("/index.html").await.unwrap();
-    framed
-        .send(ws::Message::Text("text".to_string()))
-        .await
+    let framed = srv.ws_at("/index.html").unwrap();
+    let framed = srv
+        .block_on(framed.send(ws::Message::Text("text".to_string())))
        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    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.unwrap().unwrap(),
-        ws::Frame::Text(Bytes::from_static(b"text"))
+        item,
+        Some(ws::Frame::Binary(Some(Bytes::from_static(b"text").into())))
    );

-    framed
-        .send(ws::Message::Binary("text".into()))
-        .await
+    let framed = srv
+        .block_on(framed.send(ws::Message::Ping("text".into())))
        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Binary(Bytes::from_static(b"text"))
-    );
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(item, Some(ws::Frame::Pong("text".to_string().into())));

-    framed.send(ws::Message::Ping("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Pong("text".to_string().into())
-    );
-
-    framed
-        .send(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
-        .await
+    let framed = srv
+        .block_on(framed.send(ws::Message::Close(Some(ws::CloseCode::Normal.into()))))
        .unwrap();

-    let (item, _) = framed.into_future().await;
+    let (item, _framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
+        item,
+        Some(ws::Frame::Close(Some(ws::CloseCode::Normal.into())))
    );
 }

-#[actix_rt::test]
-async fn test_service() {
-    let mut srv = test_server(|| {
-        pipeline_factory(actix_http::h1::OneRequest::new().map_err(|_| ())).and_then(
-            pipeline_factory(
-                pipeline_factory(VerifyWebSockets::default())
-                    .then(SendError::default())
-                    .map_err(|_| ()),
-            )
-            .and_then(
-                FramedApp::new()
-                    .service(FramedRoute::get("/index.html").to(ws_service))
-                    .into_factory()
-                    .map_err(|_| ()),
-            ),
+#[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(|_| ()),
+                ),
        )
-    })
-    .await;
+    });

    // non ws request
-    let res = srv.get("/index.html").send().await.unwrap();
+    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").await.is_err());
+    assert!(srv.ws_at("/test").is_err());

    // client service
-    let mut framed = srv.ws_at("/index.html").await.unwrap();
-    framed
-        .send(ws::Message::Text("text".to_string()))
-        .await
+    let framed = srv.ws_at("/index.html").unwrap();
+    let framed = srv
+        .block_on(framed.send(ws::Message::Text("text".to_string())))
        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
+    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.unwrap().unwrap(),
-        ws::Frame::Text(Bytes::from_static(b"text"))
+        item,
+        Some(ws::Frame::Binary(Some(Bytes::from_static(b"text").into())))
    );

-    framed
-        .send(ws::Message::Binary("text".into()))
-        .await
+    let framed = srv
+        .block_on(framed.send(ws::Message::Ping("text".into())))
        .unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Binary(Bytes::from_static(b"text"))
-    );
+    let (item, framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
+    assert_eq!(item, Some(ws::Frame::Pong("text".to_string().into())));

-    framed.send(ws::Message::Ping("text".into())).await.unwrap();
-    let (item, mut framed) = framed.into_future().await;
-    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Pong("text".to_string().into())
-    );
-
-    framed
-        .send(ws::Message::Close(Some(ws::CloseCode::Normal.into())))
-        .await
+    let framed = srv
+        .block_on(framed.send(ws::Message::Close(Some(ws::CloseCode::Normal.into()))))
        .unwrap();

-    let (item, _) = framed.into_future().await;
+    let (item, _framed) = srv.block_on(framed.into_future()).map_err(|_| ()).unwrap();
    assert_eq!(
-        item.unwrap().unwrap(),
-        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
+        item,
+        Some(ws::Frame::Close(Some(ws::CloseCode::Normal.into())))
    );
 }
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@ -1,117 +1,5 @@
 # Changes

-## [2.0.0-alpha.4] - 2020-05-21
-
-### Changed
-
-* Bump minimum supported Rust version to 1.40
-* content_length function is removed, and you can set Content-Length by calling no_chunking function [#1439]
-* `BodySize::Sized64` variant has been removed. `BodySize::Sized` now receives a
-  `u64` instead of a `usize`.
-* Update `base64` dependency to 0.12
-
-### Fixed
-
-* Support parsing of `SameSite=None` [#1503]
-
-[#1439]: https://github.com/actix/actix-web/pull/1439
-[#1503]: https://github.com/actix/actix-web/pull/1503
-
-## [2.0.0-alpha.3] - 2020-05-08
-
-### Fixed
-
-* Correct spelling of ConnectError::Unresolved [#1487]
-* Fix a mistake in the encoding of websocket continuation messages wherein
-  Item::FirstText and Item::FirstBinary are each encoded as the other.
-
-### Changed
-
-* Implement `std::error::Error` for our custom errors [#1422]
-* Remove `failure` support for `ResponseError` since that crate
-  will be deprecated in the near future.
-
-[#1422]: https://github.com/actix/actix-web/pull/1422
-[#1487]: https://github.com/actix/actix-web/pull/1487
-
-## [2.0.0-alpha.2] - 2020-03-07
-
-### Changed
-
-* Update `actix-connect` and `actix-tls` dependency to 2.0.0-alpha.1. [#1395]
-
-* Change default initial window size and connection window size for HTTP2 to 2MB and 1MB respectively
-  to improve download speed for awc when downloading large objects. [#1394]
-
-* client::Connector accepts initial_window_size and initial_connection_window_size HTTP2 configuration. [#1394]
-
-* client::Connector allowing to set max_http_version to limit HTTP version to be used. [#1394]
-
-[#1394]: https://github.com/actix/actix-web/pull/1394
-[#1395]: https://github.com/actix/actix-web/pull/1395
-
-## [2.0.0-alpha.1] - 2020-02-27
-
-### Changed
-
-* Update the `time` dependency to 0.2.7.
-* Moved actors messages support from actix crate, enabled with feature `actors`.
-* Breaking change: trait MessageBody requires Unpin and accepting Pin<&mut Self> instead of &mut self in the poll_next().
-* MessageBody is not implemented for &'static [u8] anymore.
-
-### Fixed
-
-* Allow `SameSite=None` cookies to be sent in a response.
-
-## [1.0.1] - 2019-12-20
-
-### Fixed
-
-* Poll upgrade service's readiness from HTTP service handlers
-
-* Replace brotli with brotli2 #1224
-
-## [1.0.0] - 2019-12-13
-
-### Added
-
-* Add websockets continuation frame support
-
-### Changed
-
-* Replace `flate2-xxx` features with `compress`
-
-## [1.0.0-alpha.5] - 2019-12-09
-
-### Fixed
-
-* Check `Upgrade` service readiness before calling it
-
-* Fix buffer remaining capacity calcualtion
-
-### Changed
-
-* Websockets: Ping and Pong should have binary data #1049
-
-## [1.0.0-alpha.4] - 2019-12-08
-
-### Added
-
-* Add impl ResponseBuilder for Error
-
-### Changed
-
-* Use rust based brotli compression library
-
-## [1.0.0-alpha.3] - 2019-12-07
-
-### Changed
-
-* Migrate to tokio 0.2
-
-* Migrate to `std::future`
-
-
 ## [0.2.11] - 2019-11-06

 ### Added
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-http"
-version = "2.0.0-alpha.4"
+version = "0.2.11"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix http primitives"
 readme = "README.md"
@ -13,9 +13,10 @@ categories = ["network-programming", "asynchronous",
              "web-programming::websocket"]
 license = "MIT/Apache-2.0"
 edition = "2018"
+workspace = ".."

 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
+features = ["ssl", "fail", "brotli", "flate2-zlib", "secure-cookies"]

 [lib]
 name = "actix_http"
@ -25,83 +26,85 @@ path = "src/lib.rs"
 default = []

 # openssl
-openssl = ["actix-tls/openssl", "actix-connect/openssl"]
+ssl = ["openssl", "actix-connect/ssl"]

 # rustls support
-rustls = ["actix-tls/rustls", "actix-connect/rustls"]
+rust-tls = ["rustls", "webpki-roots", "actix-connect/rust-tls"]

-# enable compressison support
-compress = ["flate2", "brotli2"]
+# 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"]

-# support for actix Actor messages
-actors = ["actix"]
-
 [dependencies]
-actix-service = "1.0.5"
-actix-codec = "0.2.0"
-actix-connect = "2.0.0-alpha.3"
-actix-utils = "1.0.6"
-actix-rt = "1.0.0"
-actix-threadpool = "0.3.1"
-actix-tls = { version = "2.0.0-alpha.1", optional = true }
-actix = { version = "0.10.0-alpha.1", optional = true }
+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.12"
-bitflags = "1.2"
-bytes = "0.5.3"
+base64 = "0.10"
+bitflags = "1.0"
+bytes = "0.4"
 copyless = "0.1.4"
-derive_more = "0.99.2"
-either = "1.5.3"
+derive_more = "0.15.0"
+either = "1.5.2"
 encoding_rs = "0.8"
-futures-channel = { version = "0.3.5", default-features = false }
-futures-core = { version = "0.3.5", default-features = false }
-futures-util = { version = "0.3.5", default-features = false }
-fxhash = "0.2.1"
-h2 = "0.2.1"
-http = "0.2.0"
+futures = "0.1.25"
+hashbrown = "0.6.3"
+h2 = "0.1.16"
+http = "0.1.17"
 httparse = "1.3"
-indexmap = "1.3"
-itoa = "0.4"
-lazy_static = "1.4"
+indexmap = "1.2"
+lazy_static = "1.0"
 language-tags = "0.2"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
-pin-project = "0.4.6"
 rand = "0.7"
-regex = "1.3"
+regex = "1.0"
 serde = "1.0"
 serde_json = "1.0"
-sha-1 = "0.8"
+sha1 = "0.6"
 slab = "0.4"
 serde_urlencoded = "0.6.1"
-time = { version = "0.2.7", default-features = false, features = ["std"] }
+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.16.9", optional = true }
+ring = { version = "0.14.6", optional = true }

 # compression
 brotli2 = { version="0.3.2", optional = true }
-flate2 = { version = "1.0.13", 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-server = "1.0.1"
-actix-connect = { version = "2.0.0-alpha.2", features = ["openssl"] }
-actix-http-test = { version = "2.0.0-alpha.1", features = ["openssl"] }
-actix-tls = { version = "2.0.0-alpha.1", features = ["openssl"] }
-criterion = "0.3"
-env_logger = "0.7"
+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"
-open-ssl = { version="0.10", package = "openssl" }
-rust-tls = { version="0.17", package = "rustls" }
-
-[[bench]]
-name = "content-length"
-harness = false
-
-[[bench]]
-name = "status-line"
-harness = false
+openssl = { version="0.10" }
+tokio-tcp = "0.1"
--- a/actix-http/README.md
+++ b/actix-http/README.md
@ -8,40 +8,25 @@ Actix http
 * [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.40 or later
+* Minimum supported Rust version: 1.31 or later

 ## Example

 ```rust
 // see examples/framed_hello.rs for complete list of used crates.
-use std::{env, io};
+extern crate actix_http;
+use actix_http::{h1, Response, ServiceConfig};

-use actix_http::{HttpService, Response};
-use actix_server::Server;
-use futures::future;
-use http::header::HeaderValue;
-use log::info;
-
-#[actix_rt::main]
-async 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!"))
-                })
-                .tcp()
-        })?
-        .run()
-        .await
+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();
 }
 ```

--- a/actix-http/benches/content-length.rs
+++ b/actix-http/benches/content-length.rs
@ -1,291 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-
-use bytes::BytesMut;
-
-// benchmark sending all requests at the same time
-fn bench_write_content_length(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_content_length");
-
-    let sizes = [
-        0, 1, 11, 83, 101, 653, 1001, 6323, 10001, 56329, 100001, 123456, 98724245,
-        4294967202,
-    ];
-
-    for i in sizes.iter() {
-        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _original::write_content_length(i, &mut b)
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _new::write_content_length(i, &mut b)
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("itoa", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _itoa::write_content_length(i, &mut b)
-            })
-        });
-    }
-
-    group.finish();
-}
-
-criterion_group!(benches, bench_write_content_length);
-criterion_main!(benches);
-
-mod _itoa {
-    use bytes::{BufMut, BytesMut};
-
-    pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
-        if n == 0 {
-            bytes.put_slice(b"\r\ncontent-length: 0\r\n");
-            return;
-        }
-
-        let mut buf = itoa::Buffer::new();
-
-        bytes.put_slice(b"\r\ncontent-length: ");
-        bytes.put_slice(buf.format(n).as_bytes());
-        bytes.put_slice(b"\r\n");
-    }
-}
-
-mod _new {
-    use bytes::{BufMut, BytesMut};
-
-    const DIGITS_START: u8 = b'0';
-
-    /// NOTE: bytes object has to contain enough space
-    pub fn write_content_length(n: usize, bytes: &mut BytesMut) {
-        if n == 0 {
-            bytes.put_slice(b"\r\ncontent-length: 0\r\n");
-            return;
-        }
-
-        bytes.put_slice(b"\r\ncontent-length: ");
-
-        if n < 10 {
-            bytes.put_u8(DIGITS_START + (n as u8));
-        } else if n < 100 {
-            let n = n as u8;
-
-            let d10 = n / 10;
-            let d1 = n % 10;
-
-            bytes.put_u8(DIGITS_START + d10);
-            bytes.put_u8(DIGITS_START + d1);
-        } else if n < 1000 {
-            let n = n as u16;
-
-            let d100 = (n / 100) as u8;
-            let d10 = ((n / 10) % 10) as u8;
-            let d1 = (n % 10) as u8;
-
-            bytes.put_u8(DIGITS_START + d100);
-            bytes.put_u8(DIGITS_START + d10);
-            bytes.put_u8(DIGITS_START + d1);
-        } else if n < 10_000 {
-            let n = n as u16;
-
-            let d1000 = (n / 1000) as u8;
-            let d100 = ((n / 100) % 10) as u8;
-            let d10 = ((n / 10) % 10) as u8;
-            let d1 = (n % 10) as u8;
-
-            bytes.put_u8(DIGITS_START + d1000);
-            bytes.put_u8(DIGITS_START + d100);
-            bytes.put_u8(DIGITS_START + d10);
-            bytes.put_u8(DIGITS_START + d1);
-        } else if n < 100_000 {
-            let n = n as u32;
-
-            let d10000 = (n / 10000) as u8;
-            let d1000 = ((n / 1000) % 10) as u8;
-            let d100 = ((n / 100) % 10) as u8;
-            let d10 = ((n / 10) % 10) as u8;
-            let d1 = (n % 10) as u8;
-
-            bytes.put_u8(DIGITS_START + d10000);
-            bytes.put_u8(DIGITS_START + d1000);
-            bytes.put_u8(DIGITS_START + d100);
-            bytes.put_u8(DIGITS_START + d10);
-            bytes.put_u8(DIGITS_START + d1);
-        } else if n < 1_000_000 {
-            let n = n as u32;
-
-            let d100000 = (n / 100000) as u8;
-            let d10000 = ((n / 10000) % 10) as u8;
-            let d1000 = ((n / 1000) % 10) as u8;
-            let d100 = ((n / 100) % 10) as u8;
-            let d10 = ((n / 10) % 10) as u8;
-            let d1 = (n % 10) as u8;
-
-            bytes.put_u8(DIGITS_START + d100000);
-            bytes.put_u8(DIGITS_START + d10000);
-            bytes.put_u8(DIGITS_START + d1000);
-            bytes.put_u8(DIGITS_START + d100);
-            bytes.put_u8(DIGITS_START + d10);
-            bytes.put_u8(DIGITS_START + d1);
-        } else {
-            write_usize(n, bytes);
-        }
-
-        bytes.put_slice(b"\r\n");
-    }
-
-    fn write_usize(n: usize, bytes: &mut BytesMut) {
-        let mut n = n;
-
-        // 20 chars is max length of a usize (2^64)
-        // digits will be added to the buffer from lsd to msd
-        let mut buf = BytesMut::with_capacity(20);
-
-        while n > 9 {
-            // "pop" the least-significant digit
-            let lsd = (n % 10) as u8;
-
-            // remove the lsd from n
-            n = n / 10;
-
-            buf.put_u8(DIGITS_START + lsd);
-        }
-
-        // put msd to result buffer
-        bytes.put_u8(DIGITS_START + (n as u8));
-
-        // put, in reverse (msd to lsd), remaining digits to buffer
-        for i in (0..buf.len()).rev() {
-            bytes.put_u8(buf[i]);
-        }
-    }
-}
-
-mod _original {
-    use std::{mem, ptr, slice};
-
-    use bytes::{BufMut, BytesMut};
-
-    const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
-          2021222324252627282930313233343536373839\
-          4041424344454647484950515253545556575859\
-          6061626364656667686970717273747576777879\
-          8081828384858687888990919293949596979899";
-
-    /// NOTE: bytes object has to contain enough space
-    pub fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
-        if n < 10 {
-            let mut buf: [u8; 21] = [
-                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
-                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'\r', b'\n',
-            ];
-            buf[18] = (n as u8) + b'0';
-            bytes.put_slice(&buf);
-        } else if n < 100 {
-            let mut buf: [u8; 22] = [
-                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
-                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'\r', b'\n',
-            ];
-            let d1 = n << 1;
-            unsafe {
-                ptr::copy_nonoverlapping(
-                    DEC_DIGITS_LUT.as_ptr().add(d1),
-                    buf.as_mut_ptr().offset(18),
-                    2,
-                );
-            }
-            bytes.put_slice(&buf);
-        } else if n < 1000 {
-            let mut buf: [u8; 23] = [
-                b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l',
-                b'e', b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'0', b'\r',
-                b'\n',
-            ];
-            // decode 2 more chars, if > 2 chars
-            let d1 = (n % 100) << 1;
-            n /= 100;
-            unsafe {
-                ptr::copy_nonoverlapping(
-                    DEC_DIGITS_LUT.as_ptr().add(d1),
-                    buf.as_mut_ptr().offset(19),
-                    2,
-                )
-            };
-
-            // decode last 1
-            buf[18] = (n as u8) + b'0';
-
-            bytes.put_slice(&buf);
-        } else {
-            bytes.put_slice(b"\r\ncontent-length: ");
-            convert_usize(n, bytes);
-        }
-    }
-
-    pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
-        let mut curr: isize = 39;
-        let mut buf: [u8; 41] = unsafe { mem::MaybeUninit::uninit().assume_init() };
-        buf[39] = b'\r';
-        buf[40] = b'\n';
-        let buf_ptr = buf.as_mut_ptr();
-        let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-
-        // eagerly decode 4 characters at a time
-        while n >= 10_000 {
-            let rem = (n % 10_000) as isize;
-            n /= 10_000;
-
-            let d1 = (rem / 100) << 1;
-            let d2 = (rem % 100) << 1;
-            curr -= 4;
-            unsafe {
-                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
-                ptr::copy_nonoverlapping(
-                    lut_ptr.offset(d2),
-                    buf_ptr.offset(curr + 2),
-                    2,
-                );
-            }
-        }
-
-        // if we reach here numbers are <= 9999, so at most 4 chars long
-        let mut n = n as isize; // possibly reduce 64bit math
-
-        // decode 2 more chars, if > 2 chars
-        if n >= 100 {
-            let d1 = (n % 100) << 1;
-            n /= 100;
-            curr -= 2;
-            unsafe {
-                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
-            }
-        }
-
-        // decode last 1 or 2 chars
-        if n < 10 {
-            curr -= 1;
-            unsafe {
-                *buf_ptr.offset(curr) = (n as u8) + b'0';
-            }
-        } else {
-            let d1 = n << 1;
-            curr -= 2;
-            unsafe {
-                ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
-            }
-        }
-
-        unsafe {
-            bytes.extend_from_slice(slice::from_raw_parts(
-                buf_ptr.offset(curr),
-                41 - curr as usize,
-            ));
-        }
-    }
-}
--- a/actix-http/benches/status-line.rs
+++ b/actix-http/benches/status-line.rs
@ -1,222 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-
-use bytes::BytesMut;
-use http::Version;
-
-const CODES: &[u16] = &[201, 303, 404, 515];
-
-fn bench_write_status_line_11(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_status_line v1.1");
-
-    let version = Version::HTTP_11;
-
-    for i in CODES.iter() {
-        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _original::write_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _new::write_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _naive::write_status_line(version, i, &mut b);
-            })
-        });
-    }
-
-    group.finish();
-}
-
-fn bench_write_status_line_10(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_status_line v1.0");
-
-    let version = Version::HTTP_10;
-
-    for i in CODES.iter() {
-        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _original::write_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _new::write_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _naive::write_status_line(version, i, &mut b);
-            })
-        });
-    }
-
-    group.finish();
-}
-
-fn bench_write_status_line_09(c: &mut Criterion) {
-    let mut group = c.benchmark_group("write_status_line v0.9");
-
-    let version = Version::HTTP_09;
-
-    for i in CODES.iter() {
-        group.bench_with_input(BenchmarkId::new("Original (unsafe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _original::write_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("New (safe)", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _new::write_status_line(version, i, &mut b);
-            })
-        });
-
-        group.bench_with_input(BenchmarkId::new("Naive", i), i, |b, &i| {
-            b.iter(|| {
-                let mut b = BytesMut::with_capacity(35);
-                _naive::write_status_line(version, i, &mut b);
-            })
-        });
-    }
-
-    group.finish();
-}
-
-criterion_group!(
-    benches,
-    bench_write_status_line_11,
-    bench_write_status_line_10,
-    bench_write_status_line_09
-);
-criterion_main!(benches);
-
-mod _naive {
-    use bytes::{BufMut, BytesMut};
-    use http::Version;
-
-    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
-        match version {
-            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
-            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
-            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
-            _ => {
-                // other HTTP version handlers do not use this method
-            }
-        }
-
-        bytes.put_slice(n.to_string().as_bytes());
-    }
-}
-
-mod _new {
-    use bytes::{BufMut, BytesMut};
-    use http::Version;
-
-    const DIGITS_START: u8 = b'0';
-
-    pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
-        match version {
-            Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
-            Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
-            Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
-            _ => {
-                // other HTTP version handlers do not use this method
-            }
-        }
-
-        let d100 = (n / 100) as u8;
-        let d10 = ((n / 10) % 10) as u8;
-        let d1 = (n % 10) as u8;
-
-        bytes.put_u8(DIGITS_START + d100);
-        bytes.put_u8(DIGITS_START + d10);
-        bytes.put_u8(DIGITS_START + d1);
-
-        bytes.put_u8(b' ');
-    }
-}
-
-mod _original {
-    use std::ptr;
-
-    use bytes::{BufMut, BytesMut};
-    use http::Version;
-
-    const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
-        2021222324252627282930313233343536373839\
-        4041424344454647484950515253545556575859\
-        6061626364656667686970717273747576777879\
-        8081828384858687888990919293949596979899";
-
-    pub(crate) const STATUS_LINE_BUF_SIZE: usize = 13;
-
-    pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
-        let mut buf: [u8; STATUS_LINE_BUF_SIZE] = *b"HTTP/1.1     ";
-
-        match version {
-            Version::HTTP_2 => buf[5] = b'2',
-            Version::HTTP_10 => buf[7] = b'0',
-            Version::HTTP_09 => {
-                buf[5] = b'0';
-                buf[7] = b'9';
-            }
-            _ => (),
-        }
-
-        let mut curr: isize = 12;
-        let buf_ptr = buf.as_mut_ptr();
-        let lut_ptr = DEC_DIGITS_LUT.as_ptr();
-        let four = n > 999;
-
-        // decode 2 more chars, if > 2 chars
-        let d1 = (n % 100) << 1;
-        n /= 100;
-        curr -= 2;
-        unsafe {
-            ptr::copy_nonoverlapping(
-                lut_ptr.offset(d1 as isize),
-                buf_ptr.offset(curr),
-                2,
-            );
-        }
-
-        // decode last 1 or 2 chars
-        if n < 10 {
-            curr -= 1;
-            unsafe {
-                *buf_ptr.offset(curr) = (n as u8) + b'0';
-            }
-        } else {
-            let d1 = n << 1;
-            curr -= 2;
-            unsafe {
-                ptr::copy_nonoverlapping(
-                    lut_ptr.offset(d1 as isize),
-                    buf_ptr.offset(curr),
-                    2,
-                );
-            }
-        }
-
-        bytes.put_slice(&buf);
-        if four {
-            bytes.put_u8(b' ');
-        }
-    }
-}
--- a/actix-http/examples/echo.rs
+++ b/actix-http/examples/echo.rs
@ -1,14 +1,13 @@
 use std::{env, io};

-use actix_http::{Error, HttpService, Request, Response};
+use actix_http::{error::PayloadError, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures_util::StreamExt;
+use futures::{Future, Stream};
 use http::header::HeaderValue;
 use log::info;

-#[actix_rt::main]
-async fn main() -> io::Result<()> {
+fn main() -> io::Result<()> {
    env::set_var("RUST_LOG", "echo=info");
    env_logger::init();

@ -17,21 +16,22 @@ async fn main() -> io::Result<()> {
            HttpService::build()
                .client_timeout(1000)
                .client_disconnect(1000)
-                .finish(|mut req: Request| async move {
-                    let mut body = BytesMut::new();
-                    while let Some(item) = req.payload().next().await {
-                        body.extend_from_slice(&item?);
-                    }
-
-                    info!("request body: {:?}", body);
-                    Ok::<_, Error>(
-                        Response::Ok()
-                            .header("x-head", HeaderValue::from_static("dummy value!"))
-                            .body(body),
-                    )
+                .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))
+                        })
                })
-                .tcp()
        })?
        .run()
-        .await
 }
--- a/actix-http/examples/echo2.rs
+++ b/actix-http/examples/echo2.rs
@ -1,33 +1,34 @@
 use std::{env, io};

 use actix_http::http::HeaderValue;
-use actix_http::{Error, HttpService, Request, Response};
+use actix_http::{error::PayloadError, Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures_util::StreamExt;
+use futures::{Future, Stream};
 use log::info;

-async fn handle_request(mut req: Request) -> Result<Response, Error> {
-    let mut body = BytesMut::new();
-    while let Some(item) = req.payload().next().await {
-        body.extend_from_slice(&item?)
-    }
-
-    info!("request body: {:?}", body);
-    Ok(Response::Ok()
-        .header("x-head", HeaderValue::from_static("dummy value!"))
-        .body(body))
+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))
+        })
 }

-#[actix_rt::main]
-async fn main() -> io::Result<()> {
+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(handle_request).tcp()
+            HttpService::build().finish(|_req: Request| handle_request(_req))
        })?
        .run()
-        .await
 }
--- a/actix-http/examples/hello-world.rs
+++ b/actix-http/examples/hello-world.rs
@ -2,12 +2,11 @@ use std::{env, io};

 use actix_http::{HttpService, Response};
 use actix_server::Server;
-use futures_util::future;
+use futures::future;
 use http::header::HeaderValue;
 use log::info;

-#[actix_rt::main]
-async fn main() -> io::Result<()> {
+fn main() -> io::Result<()> {
    env::set_var("RUST_LOG", "hello_world=info");
    env_logger::init();

@ -22,8 +21,6 @@ async fn main() -> io::Result<()> {
                    res.header("x-head", HeaderValue::from_static("dummy value!"));
                    future::ok::<_, ()>(res.body("Hello world!"))
                })
-                .tcp()
        })?
        .run()
-        .await
 }
--- a/actix-http/src/body.rs
+++ b/actix-http/src/body.rs
@ -1,12 +1,8 @@
 use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
 use std::{fmt, mem};

 use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
-use futures_util::ready;
-use pin_project::{pin_project, project};
+use futures::{Async, Poll, Stream};

 use crate::error::Error;

@ -15,7 +11,8 @@ use crate::error::Error;
 pub enum BodySize {
    None,
    Empty,
-    Sized(u64),
+    Sized(usize),
+    Sized64(u64),
    Stream,
 }

@ -24,7 +21,8 @@ impl BodySize {
        match self {
            BodySize::None
            | BodySize::Empty
-            | BodySize::Sized(0) => true,
+            | BodySize::Sized(0)
+            | BodySize::Sized64(0) => true,
            _ => false,
        }
    }
@ -34,46 +32,32 @@ impl BodySize {
 pub trait MessageBody {
    fn size(&self) -> BodySize;

-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>>;
-
-    downcast_get_type_id!();
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error>;
 }

-downcast!(MessageBody);
-
 impl MessageBody for () {
    fn size(&self) -> BodySize {
        BodySize::Empty
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        Poll::Ready(None)
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
+        Ok(Async::Ready(None))
    }
 }

-impl<T: MessageBody + Unpin> MessageBody for Box<T> {
+impl<T: MessageBody> MessageBody for Box<T> {
    fn size(&self) -> BodySize {
        self.as_ref().size()
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        Pin::new(self.get_mut().as_mut()).poll_next(cx)
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
+        self.as_mut().poll_next()
    }
 }

-#[pin_project]
 pub enum ResponseBody<B> {
-    Body(#[pin] B),
-    Other(#[pin] Body),
+    Body(B),
+    Other(Body),
 }

 impl ResponseBody<Body> {
@ -109,36 +93,23 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
        }
    }

-    #[project]
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        #[project]
-        match self.project() {
-            ResponseBody::Body(body) => body.poll_next(cx),
-            ResponseBody::Other(body) => body.poll_next(cx),
+    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 = Result<Bytes, Error>;
+    type Item = Bytes;
+    type Error = Error;

-    #[project]
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        #[project]
-        match self.project() {
-            ResponseBody::Body(body) => body.poll_next(cx),
-            ResponseBody::Other(body) => body.poll_next(cx),
-        }
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        self.poll_next()
    }
 }

-#[pin_project]
 /// Represents various types of http message body.
 pub enum Body {
    /// Empty response. `Content-Length` header is not set.
@ -148,17 +119,17 @@ pub enum Body {
    /// Specific response body.
    Bytes(Bytes),
    /// Generic message body.
-    Message(Box<dyn MessageBody + Unpin>),
+    Message(Box<dyn MessageBody>),
 }

 impl Body {
    /// Create body from slice (copy)
    pub fn from_slice(s: &[u8]) -> Body {
-        Body::Bytes(Bytes::copy_from_slice(s))
+        Body::Bytes(Bytes::from(s))
    }

    /// Create body from generic message body.
-    pub fn from_message<B: MessageBody + Unpin + 'static>(body: B) -> Body {
+    pub fn from_message<B: MessageBody + 'static>(body: B) -> Body {
        Body::Message(Box::new(body))
    }
 }
@ -168,29 +139,24 @@ impl MessageBody for Body {
        match self {
            Body::None => BodySize::None,
            Body::Empty => BodySize::Empty,
-            Body::Bytes(ref bin) => BodySize::Sized(bin.len() as u64),
+            Body::Bytes(ref bin) => BodySize::Sized(bin.len()),
            Body::Message(ref body) => body.size(),
        }
    }

-    #[project]
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        #[project]
-        match self.project() {
-            Body::None => Poll::Ready(None),
-            Body::Empty => Poll::Ready(None),
+    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 {
-                    Poll::Ready(None)
+                    Ok(Async::Ready(None))
                } else {
-                    Poll::Ready(Some(Ok(mem::take(bin))))
+                    Ok(Async::Ready(Some(mem::replace(bin, Bytes::new()))))
                }
            }
-            Body::Message(ref mut body) => Pin::new(body.as_mut()).poll_next(cx),
+            Body::Message(ref mut body) => body.poll_next(),
        }
    }
 }
@ -216,7 +182,7 @@ impl PartialEq for Body {
 }

 impl fmt::Debug for Body {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Body::None => write!(f, "Body::None"),
            Body::Empty => write!(f, "Body::Empty"),
@ -252,7 +218,7 @@ impl From<String> for Body {

 impl<'a> From<&'a String> for Body {
    fn from(s: &'a String) -> Body {
-        Body::Bytes(Bytes::copy_from_slice(AsRef::<[u8]>::as_ref(&s)))
+        Body::Bytes(Bytes::from(AsRef::<[u8]>::as_ref(&s)))
    }
 }

@ -276,7 +242,7 @@ impl From<serde_json::Value> for Body {

 impl<S> From<SizedStream<S>> for Body
 where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin + 'static,
+    S: Stream<Item = Bytes, Error = Error> + 'static,
 {
    fn from(s: SizedStream<S>) -> Body {
        Body::from_message(s)
@ -285,7 +251,7 @@ where

 impl<S, E> From<BodyStream<S, E>> for Body
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
+    S: Stream<Item = Bytes, Error = E> + 'static,
    E: Into<Error> + 'static,
 {
    fn from(s: BodyStream<S, E>) -> Body {
@ -295,88 +261,94 @@ where

 impl MessageBody for Bytes {
    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
+        BodySize::Sized(self.len())
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
-            Poll::Ready(None)
+            Ok(Async::Ready(None))
        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
+            Ok(Async::Ready(Some(mem::replace(self, Bytes::new()))))
        }
    }
 }

 impl MessageBody for BytesMut {
    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
+        BodySize::Sized(self.len())
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
-            Poll::Ready(None)
+            Ok(Async::Ready(None))
        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
+            Ok(Async::Ready(Some(
+                mem::replace(self, BytesMut::new()).freeze(),
+            )))
        }
    }
 }

 impl MessageBody for &'static str {
    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
+        BodySize::Sized(self.len())
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
-            Poll::Ready(None)
+            Ok(Async::Ready(None))
        } else {
-            Poll::Ready(Some(Ok(Bytes::from_static(
-                mem::take(self.get_mut()).as_ref(),
+            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() as u64)
+        BodySize::Sized(self.len())
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
-            Poll::Ready(None)
+            Ok(Async::Ready(None))
        } else {
-            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
+            Ok(Async::Ready(Some(Bytes::from(mem::replace(
+                self,
+                Vec::new(),
+            )))))
        }
    }
 }

 impl MessageBody for String {
    fn size(&self) -> BodySize {
-        BodySize::Sized(self.len() as u64)
+        BodySize::Sized(self.len())
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        if self.is_empty() {
-            Poll::Ready(None)
+            Ok(Async::Ready(None))
        } else {
-            Poll::Ready(Some(Ok(Bytes::from(
-                mem::take(self.get_mut()).into_bytes(),
+            Ok(Async::Ready(Some(Bytes::from(
+                mem::replace(self, String::new()).into_bytes(),
            ))))
        }
    }
@ -384,16 +356,14 @@ impl MessageBody for String {

 /// Type represent streaming body.
 /// Response does not contain `content-length` header and appropriate transfer encoding is used.
-#[pin_project]
-pub struct BodyStream<S: Unpin, E> {
-    #[pin]
+pub struct BodyStream<S, E> {
    stream: S,
    _t: PhantomData<E>,
 }

 impl<S, E> BodyStream<S, E>
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    S: Stream<Item = Bytes, Error = E>,
    E: Into<Error>,
 {
    pub fn new(stream: S) -> Self {
@ -406,45 +376,28 @@ where

 impl<S, E> MessageBody for BodyStream<S, E>
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    S: Stream<Item = Bytes, Error = E>,
    E: Into<Error>,
 {
    fn size(&self) -> BodySize {
        BodySize::Stream
    }

-    /// Attempts to pull out the next value of the underlying [`Stream`].
-    ///
-    /// Empty values are skipped to prevent [`BodyStream`]'s transmission being
-    /// ended on a zero-length chunk, but rather proceed until the underlying
-    /// [`Stream`] ends.
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        let mut stream = self.project().stream;
-        loop {
-            let stream = stream.as_mut();
-            return Poll::Ready(match ready!(stream.poll_next(cx)) {
-                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                opt => opt.map(|res| res.map_err(Into::into)),
-            });
-        }
+    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.
-#[pin_project]
-pub struct SizedStream<S: Unpin> {
+pub struct SizedStream<S> {
    size: u64,
-    #[pin]
    stream: S,
 }

 impl<S> SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+    S: Stream<Item = Bytes, Error = Error>,
 {
    pub fn new(size: u64, stream: S) -> Self {
        SizedStream { size, stream }
@ -453,38 +406,20 @@ where

 impl<S> MessageBody for SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+    S: Stream<Item = Bytes, Error = Error>,
 {
    fn size(&self) -> BodySize {
-        BodySize::Sized(self.size as u64)
+        BodySize::Sized64(self.size)
    }

-    /// Attempts to pull out the next value of the underlying [`Stream`].
-    ///
-    /// Empty values are skipped to prevent [`SizedStream`]'s transmission being
-    /// ended on a zero-length chunk, but rather proceed until the underlying
-    /// [`Stream`] ends.
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        let mut stream: Pin<&mut S> = self.project().stream;
-        loop {
-            let stream = stream.as_mut();
-            return Poll::Ready(match ready!(stream.poll_next(cx)) {
-                Some(Ok(ref bytes)) if bytes.is_empty() => continue,
-                val => val,
-            });
-        }
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
+        self.stream.poll()
    }
 }

 #[cfg(test)]
 mod tests {
    use super::*;
-    use futures_util::stream;
-    use futures_util::future::poll_fn;
-    use futures_util::pin_mut;

    impl Body {
        pub(crate) fn get_ref(&self) -> &[u8] {
@ -504,24 +439,21 @@ mod tests {
        }
    }

-    #[actix_rt::test]
-    async fn test_static_str() {
+    #[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!(
-            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
+            "test".poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
        );
    }

-    #[actix_rt::test]
-    async fn test_static_bytes() {
+    #[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!(
@ -529,95 +461,82 @@ mod tests {
            BodySize::Sized(4)
        );
        assert_eq!(Body::from_slice(b"test".as_ref()).get_ref(), b"test");
-        let sb = Bytes::from(&b"test"[..]);
-        pin_mut!(sb);

-        assert_eq!(sb.size(), BodySize::Sized(4));
+        assert_eq!((&b"test"[..]).size(), BodySize::Sized(4));
        assert_eq!(
-            poll_fn(|cx| sb.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
+            (&b"test"[..]).poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
        );
    }

-    #[actix_rt::test]
-    async fn test_vec() {
+    #[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");
-        let test_vec = Vec::from("test");
-        pin_mut!(test_vec);

-        assert_eq!(test_vec.size(), BodySize::Sized(4));
+        assert_eq!(Vec::from("test").size(), BodySize::Sized(4));
        assert_eq!(
-            poll_fn(|cx| test_vec.as_mut().poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
-            Some(Bytes::from("test"))
+            Vec::from("test").poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
        );
    }

-    #[actix_rt::test]
-    async fn test_bytes() {
-        let b = 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");
-        pin_mut!(b);

        assert_eq!(b.size(), BodySize::Sized(4));
        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
+            b.poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
        );
    }

-    #[actix_rt::test]
-    async fn test_bytes_mut() {
-        let b = BytesMut::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");
-        pin_mut!(b);

        assert_eq!(b.size(), BodySize::Sized(4));
        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
+            b.poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
        );
    }

-    #[actix_rt::test]
-    async fn test_string() {
-        let b = "test".to_owned();
+    #[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");
-        pin_mut!(b);

        assert_eq!(b.size(), BodySize::Sized(4));
        assert_eq!(
-            poll_fn(|cx| b.as_mut().poll_next(cx)).await.unwrap().ok(),
-            Some(Bytes::from("test"))
+            b.poll_next().unwrap(),
+            Async::Ready(Some(Bytes::from("test")))
        );
    }

-    #[actix_rt::test]
-    async fn test_unit() {
+    #[test]
+    fn test_unit() {
        assert_eq!(().size(), BodySize::Empty);
-        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
-            .await
-            .is_none());
+        assert_eq!(().poll_next().unwrap(), Async::Ready(None));
    }

-    #[actix_rt::test]
-    async fn test_box() {
-        let val = Box::new(());
-        pin_mut!(val);
+    #[test]
+    fn test_box() {
+        let mut val = Box::new(());
        assert_eq!(val.size(), BodySize::Empty);
-        assert!(poll_fn(|cx| val.as_mut().poll_next(cx)).await.is_none());
+        assert_eq!(val.poll_next().unwrap(), Async::Ready(None));
    }

-    #[actix_rt::test]
-    async fn test_body_eq() {
+    #[test]
+    fn test_body_eq() {
        assert!(Body::None == Body::None);
        assert!(Body::None != Body::Empty);
        assert!(Body::Empty == Body::Empty);
@ -629,15 +548,15 @@ mod tests {
        assert!(Body::Bytes(Bytes::from_static(b"1")) != Body::None);
    }

-    #[actix_rt::test]
-    async fn test_body_debug() {
+    #[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"));
    }

-    #[actix_rt::test]
-    async fn test_serde_json() {
+    #[test]
+    fn test_serde_json() {
        use serde_json::json;
        assert_eq!(
            Body::from(serde_json::Value::String("test".into())).size(),
@ -648,97 +567,4 @@ mod tests {
            BodySize::Sized(25)
        );
    }
-
-    mod body_stream {
-        use super::*;
-        //use futures::task::noop_waker;
-        //use futures::stream::once;
-
-        #[actix_rt::test]
-        async fn skips_empty_chunks() {
-            let body = BodyStream::new(stream::iter(
-                ["1", "", "2"]
-                    .iter()
-                    .map(|&v| Ok(Bytes::from(v)) as Result<Bytes, ()>),
-            ));
-            pin_mut!(body);
-
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("1")),
-            );
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("2")),
-            );
-        }
-
-        /* Now it does not compile as it should
-        #[actix_rt::test]
-        async fn move_pinned_pointer() {
-            let (sender, receiver) = futures::channel::oneshot::channel();
-            let mut body_stream = Ok(BodyStream::new(once(async {
-                let x = Box::new(0i32);
-                let y = &x;
-                receiver.await.unwrap();
-                let _z = **y;
-                Ok::<_, ()>(Bytes::new())
-            })));
-
-            let waker = noop_waker();
-            let mut context = Context::from_waker(&waker);
-            pin_mut!(body_stream);
-
-            let _ = body_stream.as_mut().unwrap().poll_next(&mut context);
-            sender.send(()).unwrap();
-            let _ = std::mem::replace(&mut body_stream, Err([0; 32])).unwrap().poll_next(&mut context);
-        }*/
-    }
-
-    mod sized_stream {
-        use super::*;
-
-        #[actix_rt::test]
-        async fn skips_empty_chunks() {
-            let body = SizedStream::new(
-                2,
-                stream::iter(["1", "", "2"].iter().map(|&v| Ok(Bytes::from(v)))),
-            );
-            pin_mut!(body);
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("1")),
-            );
-            assert_eq!(
-                poll_fn(|cx| body.as_mut().poll_next(cx))
-                    .await
-                    .unwrap()
-                    .ok(),
-                Some(Bytes::from("2")),
-            );
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_body_casting() {
-        let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MessageBody = &mut body;
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast");
-        let body = &mut resp_body.downcast_mut::<String>().unwrap();
-        body.push_str("!");
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast!");
-        let not_body = resp_body.downcast_ref::<()>();
-        assert!(not_body.is_none());
-    }
 }
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@ -1,9 +1,10 @@
+use std::fmt;
 use std::marker::PhantomData;
 use std::rc::Rc;
-use std::{fmt, net};

 use actix_codec::Framed;
-use actix_service::{IntoServiceFactory, Service, ServiceFactory};
+use actix_server_config::ServerConfig as SrvConfig;
+use actix_service::{IntoNewService, NewService, Service};

 use crate::body::MessageBody;
 use crate::config::{KeepAlive, ServiceConfig};
@ -23,8 +24,6 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {
    keep_alive: KeepAlive,
    client_timeout: u64,
    client_disconnect: u64,
-    secure: bool,
-    local_addr: Option<net::SocketAddr>,
    expect: X,
    upgrade: Option<U>,
    on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
@ -33,10 +32,9 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler<T>> {

 impl<T, S> HttpServiceBuilder<T, S, ExpectHandler, UpgradeHandler<T>>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
-    <S::Service as Service>::Future: 'static,
 {
    /// Create instance of `ServiceConfigBuilder`
    pub fn new() -> Self {
@ -44,8 +42,6 @@ where
            keep_alive: KeepAlive::Timeout(5),
            client_timeout: 5000,
            client_disconnect: 0,
-            secure: false,
-            local_addr: None,
            expect: ExpectHandler,
            upgrade: None,
            on_connect: None,
@ -56,18 +52,19 @@ where

 impl<T, S, X, U> HttpServiceBuilder<T, S, X, U>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
+    S: NewService<Config = SrvConfig, Request = Request>,
+    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
-    <S::Service as Service>::Future: 'static,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: fmt::Debug,
-    <X::Service as Service>::Future: 'static,
-    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, Codec>),
+        Response = (),
+    >,
    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
-    <U::Service as Service>::Future: 'static,
 {
    /// Set server keep-alive setting.
    ///
@ -77,18 +74,6 @@ where
        self
    }

-    /// Set connection secure state
-    pub fn secure(mut self) -> Self {
-        self.secure = true;
-        self
-    }
-
-    /// Set the local address that this service is bound to.
-    pub fn local_addr(mut self, addr: net::SocketAddr) -> Self {
-        self.local_addr = Some(addr);
-        self
-    }
-
    /// Set server client timeout in milliseconds for first request.
    ///
    /// Defines a timeout for reading client request header. If a client does not transmit
@ -123,19 +108,16 @@ where
    /// request will be forwarded to main service.
    pub fn expect<F, X1>(self, expect: F) -> HttpServiceBuilder<T, S, X1, U>
    where
-        F: IntoServiceFactory<X1>,
-        X1: ServiceFactory<Config = (), Request = Request, Response = Request>,
+        F: IntoNewService<X1>,
+        X1: NewService<Config = SrvConfig, Request = Request, Response = Request>,
        X1::Error: Into<Error>,
        X1::InitError: fmt::Debug,
-        <X1::Service as Service>::Future: 'static,
    {
        HttpServiceBuilder {
            keep_alive: self.keep_alive,
            client_timeout: self.client_timeout,
            client_disconnect: self.client_disconnect,
-            secure: self.secure,
-            local_addr: self.local_addr,
-            expect: expect.into_factory(),
+            expect: expect.into_new_service(),
            upgrade: self.upgrade,
            on_connect: self.on_connect,
            _t: PhantomData,
@ -148,24 +130,21 @@ where
    /// 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: IntoServiceFactory<U1>,
-        U1: ServiceFactory<
-            Config = (),
+        F: IntoNewService<U1>,
+        U1: NewService<
+            Config = SrvConfig,
            Request = (Request, Framed<T, Codec>),
            Response = (),
        >,
        U1::Error: fmt::Display,
        U1::InitError: fmt::Debug,
-        <U1::Service as Service>::Future: 'static,
    {
        HttpServiceBuilder {
            keep_alive: self.keep_alive,
            client_timeout: self.client_timeout,
            client_disconnect: self.client_disconnect,
-            secure: self.secure,
-            local_addr: self.local_addr,
            expect: self.expect,
-            upgrade: Some(upgrade.into_factory()),
+            upgrade: Some(upgrade.into_new_service()),
            on_connect: self.on_connect,
            _t: PhantomData,
        }
@ -185,10 +164,10 @@ where
    }

    /// Finish service configuration and create *http service* for HTTP/1 protocol.
-    pub fn h1<F, B>(self, service: F) -> H1Service<T, S, B, X, U>
+    pub fn h1<F, P, B>(self, service: F) -> H1Service<T, P, S, B, X, U>
    where
-        B: MessageBody,
-        F: IntoServiceFactory<S>,
+        B: MessageBody + 'static,
+        F: IntoNewService<S>,
        S::Error: Into<Error>,
        S::InitError: fmt::Debug,
        S::Response: Into<Response<B>>,
@ -197,53 +176,48 @@ where
            self.keep_alive,
            self.client_timeout,
            self.client_disconnect,
-            self.secure,
-            self.local_addr,
        );
-        H1Service::with_config(cfg, service.into_factory())
+        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, B>(self, service: F) -> H2Service<T, S, B>
+    pub fn h2<F, P, B>(self, service: F) -> H2Service<T, P, S, B>
    where
        B: MessageBody + 'static,
-        F: IntoServiceFactory<S>,
-        S::Error: Into<Error> + 'static,
+        F: IntoNewService<S>,
+        S::Error: Into<Error>,
        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
+        S::Response: Into<Response<B>>,
        <S::Service as Service>::Future: 'static,
    {
        let cfg = ServiceConfig::new(
            self.keep_alive,
            self.client_timeout,
            self.client_disconnect,
-            self.secure,
-            self.local_addr,
        );
-        H2Service::with_config(cfg, service.into_factory()).on_connect(self.on_connect)
+        H2Service::with_config(cfg, service.into_new_service())
+            .on_connect(self.on_connect)
    }

    /// Finish service configuration and create `HttpService` instance.
-    pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
+    pub fn finish<F, P, B>(self, service: F) -> HttpService<T, P, S, B, X, U>
    where
        B: MessageBody + 'static,
-        F: IntoServiceFactory<S>,
-        S::Error: Into<Error> + 'static,
+        F: IntoNewService<S>,
+        S::Error: Into<Error>,
        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>> + 'static,
+        S::Response: Into<Response<B>>,
        <S::Service as Service>::Future: 'static,
    {
        let cfg = ServiceConfig::new(
            self.keep_alive,
            self.client_timeout,
            self.client_disconnect,
-            self.secure,
-            self.local_addr,
        );
-        HttpService::with_config(cfg, service.into_factory())
+        HttpService::with_config(cfg, service.into_new_service())
            .expect(self.expect)
            .upgrade(self.upgrade)
            .on_connect(self.on_connect)
--- a/actix-http/src/client/config.rs
+++ b/actix-http/src/client/config.rs
@ -1,39 +0,0 @@
-use std::time::Duration;
-
-// These values are taken from hyper/src/proto/h2/client.rs
-const DEFAULT_H2_CONN_WINDOW: u32 = 1024 * 1024 * 2; // 2mb
-const DEFAULT_H2_STREAM_WINDOW: u32 = 1024 * 1024; // 1mb
-
-/// Connector configuration
-#[derive(Clone)]
-pub(crate) struct ConnectorConfig {
-    pub(crate) timeout: Duration,
-    pub(crate) conn_lifetime: Duration,
-    pub(crate) conn_keep_alive: Duration,
-    pub(crate) disconnect_timeout: Option<Duration>,
-    pub(crate) limit: usize,
-    pub(crate) conn_window_size: u32,
-    pub(crate) stream_window_size: u32,
-}
-
-impl Default for ConnectorConfig {
-    fn default() -> Self {
-        Self {
-            timeout: Duration::from_secs(1),
-            conn_lifetime: Duration::from_secs(75),
-            conn_keep_alive: Duration::from_secs(15),
-            disconnect_timeout: Some(Duration::from_millis(3000)),
-            limit: 100,
-            conn_window_size: DEFAULT_H2_CONN_WINDOW,
-            stream_window_size: DEFAULT_H2_STREAM_WINDOW,
-        }
-    }
-}
-
-impl ConnectorConfig {
-    pub(crate) fn no_disconnect_timeout(&self) -> Self {
-        let mut res = self.clone();
-        res.disconnect_timeout = None;
-        res
-    }
-}
--- a/actix-http/src/client/connection.rs
+++ b/actix-http/src/client/connection.rs
@ -1,13 +1,10 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{fmt, io, mem, time};
+use std::{fmt, io, time};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
 use bytes::{Buf, Bytes};
-use futures_util::future::{err, Either, FutureExt, LocalBoxFuture, Ready};
+use futures::future::{err, Either, Future, FutureResult};
+use futures::Poll;
 use h2::client::SendRequest;
-use pin_project::{pin_project, project};

 use crate::body::MessageBody;
 use crate::h1::ClientCodec;
@ -24,8 +21,8 @@ pub(crate) enum ConnectionType<Io> {
 }

 pub trait Connection {
-    type Io: AsyncRead + AsyncWrite + Unpin;
-    type Future: Future<Output = Result<(ResponseHead, Payload), SendRequestError>>;
+    type Io: AsyncRead + AsyncWrite;
+    type Future: Future<Item = (ResponseHead, Payload), Error = SendRequestError>;

    fn protocol(&self) -> Protocol;

@ -37,7 +34,8 @@ pub trait Connection {
    ) -> Self::Future;

    type TunnelFuture: Future<
-        Output = Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+        Item = (ResponseHead, Framed<Self::Io, ClientCodec>),
+        Error = SendRequestError,
    >;

    /// Send request, returns Response and Framed
@ -64,7 +62,7 @@ impl<T> fmt::Debug for IoConnection<T>
 where
    T: fmt::Debug,
 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    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"),
@ -73,7 +71,7 @@ where
    }
 }

-impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {
+impl<T: AsyncRead + AsyncWrite> IoConnection<T> {
    pub(crate) fn new(
        io: ConnectionType<T>,
        created: time::Instant,
@ -93,11 +91,11 @@ impl<T: AsyncRead + AsyncWrite + Unpin> IoConnection<T> {

 impl<T> Connection for IoConnection<T>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
 {
    type Io = T;
    type Future =
-        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
+        Box<dyn Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;

    fn protocol(&self) -> Protocol {
        match self.io {
@ -113,30 +111,38 @@ where
        body: B,
    ) -> Self::Future {
        match self.io.take().unwrap() {
-            ConnectionType::H1(io) => {
-                h1proto::send_request(io, head.into(), body, self.created, self.pool)
-                    .boxed_local()
-            }
-            ConnectionType::H2(io) => {
-                h2proto::send_request(io, head.into(), body, self.created, self.pool)
-                    .boxed_local()
-            }
+            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<
-        LocalBoxFuture<
-            'static,
-            Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+        Box<
+            dyn Future<
+                Item = (ResponseHead, Framed<Self::Io, ClientCodec>),
+                Error = SendRequestError,
+            >,
        >,
-        Ready<Result<(ResponseHead, Framed<Self::Io, ClientCodec>), 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::Left(h1proto::open_tunnel(io, head.into()).boxed_local())
+                Either::A(Box::new(h1proto::open_tunnel(io, head.into())))
            }
            ConnectionType::H2(io) => {
                if let Some(mut pool) = self.pool.take() {
@ -146,7 +152,7 @@ where
                        None,
                    ));
                }
-                Either::Right(err(SendRequestError::TunnelNotSupported))
+                Either::B(err(SendRequestError::TunnelNotSupported))
            }
        }
    }
@ -160,12 +166,12 @@ pub(crate) enum EitherConnection<A, B> {

 impl<A, B> Connection for EitherConnection<A, B>
 where
-    A: AsyncRead + AsyncWrite + Unpin + 'static,
-    B: AsyncRead + AsyncWrite + Unpin + 'static,
+    A: AsyncRead + AsyncWrite + 'static,
+    B: AsyncRead + AsyncWrite + 'static,
 {
    type Io = EitherIo<A, B>;
    type Future =
-        LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>;
+        Box<dyn Future<Item = (ResponseHead, Payload), Error = SendRequestError>>;

    fn protocol(&self) -> Protocol {
        match self {
@ -185,30 +191,44 @@ where
        }
    }

-    type TunnelFuture = LocalBoxFuture<
-        'static,
-        Result<(ResponseHead, Framed<Self::Io, ClientCodec>), SendRequestError>,
+    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) => con
-                .open_tunnel(head)
-                .map(|res| res.map(|(head, framed)| (head, framed.map_io(EitherIo::A))))
-                .boxed_local(),
-            EitherConnection::B(con) => con
-                .open_tunnel(head)
-                .map(|res| res.map(|(head, framed)| (head, framed.map_io(EitherIo::B))))
-                .boxed_local(),
+            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))),
+            ),
        }
    }
 }

-#[pin_project]
 pub enum EitherIo<A, B> {
-    A(#[pin] A),
-    B(#[pin] 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>
@ -216,23 +236,7 @@ where
    A: AsyncRead,
    B: AsyncRead,
 {
-    #[project]
-    fn poll_read(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        #[project]
-        match self.project() {
-            EitherIo::A(val) => val.poll_read(cx, buf),
-            EitherIo::B(val) => val.poll_read(cx, buf),
-        }
-    }
-
-    unsafe fn prepare_uninitialized_buffer(
-        &self,
-        buf: &mut [mem::MaybeUninit<u8>],
-    ) -> bool {
+    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),
@ -240,58 +244,45 @@ where
    }
 }

+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,
 {
-    #[project]
-    fn poll_write(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        #[project]
-        match self.project() {
-            EitherIo::A(val) => val.poll_write(cx, buf),
-            EitherIo::B(val) => val.poll_write(cx, buf),
+    fn shutdown(&mut self) -> Poll<(), io::Error> {
+        match self {
+            EitherIo::A(ref mut val) => val.shutdown(),
+            EitherIo::B(ref mut val) => val.shutdown(),
        }
    }

-    #[project]
-    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
-        #[project]
-        match self.project() {
-            EitherIo::A(val) => val.poll_flush(cx),
-            EitherIo::B(val) => val.poll_flush(cx),
-        }
-    }
-
-    #[project]
-    fn poll_shutdown(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<io::Result<()>> {
-        #[project]
-        match self.project() {
-            EitherIo::A(val) => val.poll_shutdown(cx),
-            EitherIo::B(val) => val.poll_shutdown(cx),
-        }
-    }
-
-    #[project]
-    fn poll_write_buf<U: Buf>(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut U,
-    ) -> Poll<Result<usize, io::Error>>
+    fn write_buf<U: Buf>(&mut self, buf: &mut U) -> Poll<usize, io::Error>
    where
        Self: Sized,
    {
-        #[project]
-        match self.project() {
-            EitherIo::A(val) => val.poll_write_buf(cx, buf),
-            EitherIo::B(val) => val.poll_write_buf(cx, buf),
+        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
@ -6,33 +6,32 @@ use actix_codec::{AsyncRead, AsyncWrite};
 use actix_connect::{
    default_connector, Connect as TcpConnect, Connection as TcpConnection,
 };
-use actix_rt::net::TcpStream;
-use actix_service::{apply_fn, Service};
+use actix_service::{apply_fn, Service, ServiceExt};
 use actix_utils::timeout::{TimeoutError, TimeoutService};
 use http::Uri;
+use tokio_tcp::TcpStream;

-use super::config::ConnectorConfig;
 use super::connection::Connection;
 use super::error::ConnectError;
 use super::pool::{ConnectionPool, Protocol};
 use super::Connect;

-#[cfg(feature = "openssl")]
-use actix_connect::ssl::openssl::SslConnector as OpensslConnector;
+#[cfg(feature = "ssl")]
+use openssl::ssl::SslConnector as OpensslConnector;

-#[cfg(feature = "rustls")]
-use actix_connect::ssl::rustls::ClientConfig;
-#[cfg(feature = "rustls")]
+#[cfg(feature = "rust-tls")]
+use rustls::ClientConfig;
+#[cfg(feature = "rust-tls")]
 use std::sync::Arc;

-#[cfg(any(feature = "openssl", feature = "rustls"))]
+#[cfg(any(feature = "ssl", feature = "rust-tls"))]
 enum SslConnector {
-    #[cfg(feature = "openssl")]
+    #[cfg(feature = "ssl")]
    Openssl(OpensslConnector),
-    #[cfg(feature = "rustls")]
+    #[cfg(feature = "rust-tls")]
    Rustls(Arc<ClientConfig>),
 }
-#[cfg(not(any(feature = "openssl", feature = "rustls")))]
+#[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
 type SslConnector = ();

 /// Manages http client network connectivity
@ -49,17 +48,21 @@ type SslConnector = ();
 /// ```
 pub struct Connector<T, U> {
    connector: T,
-    config: ConnectorConfig,
+    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 + Unpin {}
-impl<T: AsyncRead + AsyncWrite + Unpin> Io for T {}
+trait Io: AsyncRead + AsyncWrite {}
+impl<T: AsyncRead + AsyncWrite> Io for T {}

 impl Connector<(), ()> {
-    #[allow(clippy::new_ret_no_self, clippy::let_unit_value)]
+    #[allow(clippy::new_ret_no_self)]
    pub fn new() -> Connector<
        impl Service<
                Request = TcpConnect<Uri>,
@ -68,54 +71,49 @@ impl Connector<(), ()> {
            > + 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: Self::build_ssl(vec![b"h2".to_vec(), b"http/1.1".to_vec()]),
+            ssl,
            connector: default_connector(),
-            config: ConnectorConfig::default(),
+            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,
        }
    }
-
-    // Build Ssl connector with openssl, based on supplied alpn protocols
-    #[cfg(feature = "openssl")]
-    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
-        use actix_connect::ssl::openssl::SslMethod;
-        use bytes::{BufMut, BytesMut};
-
-        let mut alpn = BytesMut::with_capacity(20);
-        for proto in protocols.iter() {
-            alpn.put_u8(proto.len() as u8);
-            alpn.put(proto.as_slice());
-        }
-
-        let mut ssl = OpensslConnector::builder(SslMethod::tls()).unwrap();
-        let _ = ssl
-            .set_alpn_protos(&alpn)
-            .map_err(|e| error!("Can not set alpn protocol: {:?}", e));
-        SslConnector::Openssl(ssl.build())
-    }
-
-    // Build Ssl connector with rustls, based on supplied alpn protocols
-    #[cfg(all(not(feature = "openssl"), feature = "rustls"))]
-    fn build_ssl(protocols: Vec<Vec<u8>>) -> SslConnector {
-        let mut config = ClientConfig::new();
-        config.set_protocols(&protocols);
-        config
-            .root_store
-            .add_server_trust_anchors(&actix_tls::rustls::TLS_SERVER_ROOTS);
-        SslConnector::Rustls(Arc::new(config))
-    }
-
-    // ssl turned off, provides empty ssl connector
-    #[cfg(not(any(feature = "openssl", feature = "rustls")))]
-    fn build_ssl(_: Vec<Vec<u8>>) -> SslConnector {}
 }

 impl<T, U> Connector<T, U> {
    /// Use custom connector.
    pub fn connector<T1, U1>(self, connector: T1) -> Connector<T1, U1>
    where
-        U1: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
+        U1: AsyncRead + AsyncWrite + fmt::Debug,
        T1: Service<
                Request = TcpConnect<Uri>,
                Response = TcpConnection<Uri, U1>,
@ -124,7 +122,11 @@ impl<T, U> Connector<T, U> {
    {
        Connector {
            connector,
-            config: self.config,
+            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,
        }
@ -133,7 +135,7 @@ impl<T, U> Connector<T, U> {

 impl<T, U> Connector<T, U>
 where
-    U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
+    U: AsyncRead + AsyncWrite + fmt::Debug + 'static,
    T: Service<
            Request = TcpConnect<Uri>,
            Response = TcpConnection<Uri, U>,
@ -144,61 +146,29 @@ where
    /// 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.config.timeout = timeout;
+        self.timeout = timeout;
        self
    }

-    #[cfg(feature = "openssl")]
+    #[cfg(feature = "ssl")]
    /// Use custom `SslConnector` instance.
    pub fn ssl(mut self, connector: OpensslConnector) -> Self {
        self.ssl = SslConnector::Openssl(connector);
        self
    }

-    #[cfg(feature = "rustls")]
+    #[cfg(feature = "rust-tls")]
    pub fn rustls(mut self, connector: Arc<ClientConfig>) -> Self {
        self.ssl = SslConnector::Rustls(connector);
        self
    }

-    /// Maximum supported http major version
-    /// Supported versions http/1.1, http/2
-    pub fn max_http_version(mut self, val: http::Version) -> Self {
-        let versions = match val {
-            http::Version::HTTP_11 => vec![b"http/1.1".to_vec()],
-            http::Version::HTTP_2 => vec![b"h2".to_vec(), b"http/1.1".to_vec()],
-            _ => {
-                unimplemented!("actix-http:client: supported versions http/1.1, http/2")
-            }
-        };
-        self.ssl = Connector::build_ssl(versions);
-        self
-    }
-
-    /// Indicates the initial window size (in octets) for
-    /// HTTP2 stream-level flow control for received data.
-    ///
-    /// The default value is 65,535 and is good for APIs, but not for big objects.
-    pub fn initial_window_size(mut self, size: u32) -> Self {
-        self.config.stream_window_size = size;
-        self
-    }
-
-    /// Indicates the initial window size (in octets) for
-    /// HTTP2 connection-level flow control for received data.
-    ///
-    /// The default value is 65,535 and is good for APIs, but not for big objects.
-    pub fn initial_connection_window_size(mut self, size: u32) -> Self {
-        self.config.conn_window_size = size;
-        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.config.limit = limit;
+        self.limit = limit;
        self
    }

@ -209,7 +179,7 @@ where
    /// 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.config.conn_keep_alive = dur;
+        self.conn_keep_alive = dur;
        self
    }

@ -219,7 +189,7 @@ where
    /// 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.config.conn_lifetime = dur;
+        self.conn_lifetime = dur;
        self
    }

@ -232,7 +202,7 @@ where
    ///
    /// By default disconnect timeout is set to 3000 milliseconds.
    pub fn disconnect_timeout(mut self, dur: Duration) -> Self {
-        self.config.disconnect_timeout = Some(dur);
+        self.disconnect_timeout = dur;
        self
    }

@ -242,11 +212,11 @@ where
    pub fn finish(
        self,
    ) -> impl Service<Request = Connect, Response = impl Connection, Error = ConnectError>
-           + Clone {
-        #[cfg(not(any(feature = "openssl", feature = "rustls")))]
+                 + Clone {
+        #[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
        {
            let connector = TimeoutService::new(
-                self.config.timeout,
+                self.timeout,
                apply_fn(self.connector, |msg: Connect, srv| {
                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
                })
@ -261,34 +231,39 @@ where
            connect_impl::InnerConnector {
                tcp_pool: ConnectionPool::new(
                    connector,
-                    self.config.no_disconnect_timeout(),
+                    self.conn_lifetime,
+                    self.conn_keep_alive,
+                    None,
+                    self.limit,
                ),
            }
        }
-        #[cfg(any(feature = "openssl", feature = "rustls"))]
+        #[cfg(any(feature = "ssl", feature = "rust-tls"))]
        {
            const H2: &[u8] = b"h2";
-            #[cfg(feature = "openssl")]
-            use actix_connect::ssl::openssl::OpensslConnector;
-            #[cfg(feature = "rustls")]
-            use actix_connect::ssl::rustls::{RustlsConnector, Session};
-            use actix_service::{boxed::service, pipeline};
+            #[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.config.timeout,
-                pipeline(
-                    apply_fn(self.connector.clone(), |msg: Connect, srv| {
-                        srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
-                    })
-                    .map_err(ConnectError::from),
-                )
+                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 = "openssl")]
+                    #[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))
@ -298,10 +273,9 @@ where
                                } else {
                                    (Box::new(sock) as Box<dyn Io>, Protocol::Http1)
                                }
-                            })
-                            .map_err(ConnectError::from),
+                            }),
                    ),
-                    #[cfg(feature = "rustls")]
+                    #[cfg(feature = "rust-tls")]
                    SslConnector::Rustls(ssl) => service(
                        RustlsConnector::service(ssl)
                            .map_err(ConnectError::from)
@ -328,8 +302,8 @@ where
            });

            let tcp_service = TimeoutService::new(
-                self.config.timeout,
-                apply_fn(self.connector, |msg: Connect, srv| {
+                self.timeout,
+                apply_fn(self.connector.clone(), |msg: Connect, srv| {
                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
                })
                .map_err(ConnectError::from)
@ -343,27 +317,36 @@ where
            connect_impl::InnerConnector {
                tcp_pool: ConnectionPool::new(
                    tcp_service,
-                    self.config.no_disconnect_timeout(),
+                    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,
                ),
-                ssl_pool: ConnectionPool::new(ssl_service, self.config),
            }
        }
    }
 }

-#[cfg(not(any(feature = "openssl", feature = "rustls")))]
+#[cfg(not(any(feature = "ssl", feature = "rust-tls")))]
 mod connect_impl {
-    use std::task::{Context, Poll};
-
-    use futures_util::future::{err, Either, Ready};
+    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 + Unpin + 'static,
+        Io: AsyncRead + AsyncWrite + 'static,
        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
            + 'static,
    {
        pub(crate) tcp_pool: ConnectionPool<T, Io>,
@ -371,8 +354,9 @@ mod connect_impl {

    impl<T, Io> Clone for InnerConnector<T, Io>
    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
+        Io: AsyncRead + AsyncWrite + 'static,
        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
            + 'static,
    {
        fn clone(&self) -> Self {
@ -384,8 +368,9 @@ mod connect_impl {

    impl<T, Io> Service for InnerConnector<T, Io>
    where
-        Io: AsyncRead + AsyncWrite + Unpin + 'static,
+        Io: AsyncRead + AsyncWrite + 'static,
        T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+            + Clone
            + 'static,
    {
        type Request = Connect;
@ -393,41 +378,38 @@ mod connect_impl {
        type Error = ConnectError;
        type Future = Either<
            <ConnectionPool<T, Io> as Service>::Future,
-            Ready<Result<IoConnection<Io>, ConnectError>>,
+            FutureResult<IoConnection<Io>, ConnectError>,
        >;

-        fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
+        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::Right(err(ConnectError::SslIsNotSupported))
+                    Either::B(err(ConnectError::SslIsNotSupported))
                }
-                _ => Either::Left(self.tcp_pool.call(req)),
+                _ => Either::A(self.tcp_pool.call(req)),
            }
        }
    }
 }

-#[cfg(any(feature = "openssl", feature = "rustls"))]
+#[cfg(any(feature = "ssl", feature = "rust-tls"))]
 mod connect_impl {
-    use std::future::Future;
    use std::marker::PhantomData;
-    use std::pin::Pin;
-    use std::task::{Context, Poll};

-    use futures_core::ready;
-    use futures_util::future::Either;
+    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 + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+        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>,
    {
@ -437,11 +419,13 @@ mod connect_impl {

    impl<T1, T2, Io1, Io2> Clone for InnerConnector<T1, T2, Io1, Io2>
    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+        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 {
@ -454,47 +438,53 @@ mod connect_impl {

    impl<T1, T2, Io1, Io2> Service for InnerConnector<T1, T2, Io1, Io2>
    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+        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<
-            InnerConnectorResponseA<T1, Io1, Io2>,
-            InnerConnectorResponseB<T2, Io1, Io2>,
+            FutureResult<Self::Response, Self::Error>,
+            Either<
+                InnerConnectorResponseA<T1, Io1, Io2>,
+                InnerConnectorResponseB<T2, Io1, Io2>,
+            >,
        >;

-        fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-            self.tcp_pool.poll_ready(cx)
+        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::Right(InnerConnectorResponseB {
-                    fut: self.ssl_pool.call(req),
-                    _t: PhantomData,
-                }),
-                _ => Either::Left(InnerConnectorResponseA {
+                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,
-                }),
+                })),
            }
        }
    }

-    #[pin_project::pin_project]
    pub(crate) struct InnerConnectorResponseA<T, Io1, Io2>
    where
-        Io1: AsyncRead + AsyncWrite + Unpin + 'static,
+        Io1: AsyncRead + AsyncWrite + 'static,
        T: Service<Request = Connect, Response = (Io1, Protocol), Error = ConnectError>
+            + Clone
            + 'static,
    {
-        #[pin]
        fut: <ConnectionPool<T, Io1> as Service>::Future,
        _t: PhantomData<Io2>,
    }
@ -502,28 +492,29 @@ mod connect_impl {
    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 + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+        Io1: AsyncRead + AsyncWrite + 'static,
+        Io2: AsyncRead + AsyncWrite + 'static,
    {
-        type Output = Result<EitherConnection<Io1, Io2>, ConnectError>;
+        type Item = EitherConnection<Io1, Io2>;
+        type Error = ConnectError;

-        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(
-                ready!(Pin::new(&mut self.get_mut().fut).poll(cx))
-                    .map(EitherConnection::A),
-            )
+        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))),
+            }
        }
    }

-    #[pin_project::pin_project]
    pub(crate) struct InnerConnectorResponseB<T, Io1, Io2>
    where
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+        Io2: AsyncRead + AsyncWrite + 'static,
        T: Service<Request = Connect, Response = (Io2, Protocol), Error = ConnectError>
+            + Clone
            + 'static,
    {
-        #[pin]
        fut: <ConnectionPool<T, Io2> as Service>::Future,
        _t: PhantomData<Io1>,
    }
@ -531,17 +522,19 @@ mod connect_impl {
    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 + Unpin + 'static,
-        Io2: AsyncRead + AsyncWrite + Unpin + 'static,
+        Io1: AsyncRead + AsyncWrite + 'static,
+        Io2: AsyncRead + AsyncWrite + 'static,
    {
-        type Output = Result<EitherConnection<Io1, Io2>, ConnectError>;
+        type Item = EitherConnection<Io1, Io2>;
+        type Error = ConnectError;

-        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-            Poll::Ready(
-                ready!(Pin::new(&mut self.get_mut().fut).poll(cx))
-                    .map(EitherConnection::B),
-            )
+        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,13 +1,14 @@
 use std::io;

-use actix_connect::resolver::ResolveError;
 use derive_more::{Display, From};
+use trust_dns_resolver::error::ResolveError;

-#[cfg(feature = "openssl")]
-use actix_connect::ssl::openssl::{HandshakeError, SslError};
+#[cfg(feature = "ssl")]
+use openssl::ssl::{Error as SslError, HandshakeError};

 use crate::error::{Error, ParseError, ResponseError};
-use crate::http::{Error as HttpError, StatusCode};
+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)]
@ -17,15 +18,10 @@ pub enum ConnectError {
    SslIsNotSupported,

    /// SSL error
-    #[cfg(feature = "openssl")]
+    #[cfg(feature = "ssl")]
    #[display(fmt = "{}", _0)]
    SslError(SslError),

-    /// SSL Handshake error
-    #[cfg(feature = "openssl")]
-    #[display(fmt = "{}", _0)]
-    SslHandshakeError(String),
-
    /// Failed to resolve the hostname
    #[display(fmt = "Failed resolving hostname: {}", _0)]
    Resolver(ResolveError),
@ -48,31 +44,33 @@ pub enum ConnectError {

    /// Unresolved host name
    #[display(fmt = "Connector received `Connect` method with unresolved host")]
-    Unresolved,
+    Unresolverd,

    /// Connection io error
    #[display(fmt = "{}", _0)]
    Io(io::Error),
 }

-impl std::error::Error for ConnectError {}
-
 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::Unresolved => ConnectError::Unresolved,
+            actix_connect::ConnectError::Unresolverd => ConnectError::Unresolverd,
            actix_connect::ConnectError::Io(e) => ConnectError::Io(e),
        }
    }
 }

-#[cfg(feature = "openssl")]
-impl<T: std::fmt::Debug> From<HandshakeError<T>> for ConnectError {
+#[cfg(feature = "ssl")]
+impl<T> From<HandshakeError<T>> for ConnectError {
    fn from(err: HandshakeError<T>) -> ConnectError {
-        ConnectError::SslHandshakeError(format!("{:?}", err))
+        match err {
+            HandshakeError::SetupFailure(stack) => SslError::from(stack).into(),
+            HandshakeError::Failure(stream) => stream.into_error().into(),
+            HandshakeError::WouldBlock(stream) => stream.into_error().into(),
+        }
    }
 }

@ -88,8 +86,6 @@ pub enum InvalidUrl {
    HttpError(http::Error),
 }

-impl std::error::Error for InvalidUrl {}
-
 /// A set of errors that can occur during request sending and response reading
 #[derive(Debug, Display, From)]
 pub enum SendRequestError {
@ -119,18 +115,17 @@ pub enum SendRequestError {
    Body(Error),
 }

-impl std::error::Error for SendRequestError {}
-
 /// Convert `SendRequestError` to a server `Response`
 impl ResponseError for SendRequestError {
-    fn status_code(&self) -> StatusCode {
+    fn error_response(&self) -> Response {
        match *self {
            SendRequestError::Connect(ConnectError::Timeout) => {
-                StatusCode::GATEWAY_TIMEOUT
+                Response::GatewayTimeout()
            }
-            SendRequestError::Connect(_) => StatusCode::BAD_REQUEST,
-            _ => StatusCode::INTERNAL_SERVER_ERROR,
+            SendRequestError::Connect(_) => Response::BadGateway(),
+            _ => Response::InternalServerError(),
        }
+        .into()
    }
 }

@ -145,8 +140,6 @@ pub enum FreezeRequestError {
    Http(HttpError),
 }

-impl std::error::Error for FreezeRequestError {}
-
 impl From<FreezeRequestError> for SendRequestError {
    fn from(e: FreezeRequestError) -> Self {
        match e {
--- a/actix-http/src/client/h1proto.rs
+++ b/actix-http/src/client/h1proto.rs
@ -1,14 +1,10 @@
 use std::io::Write;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{io, mem, time};
+use std::{io, time};

 use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use bytes::buf::BufMutExt;
-use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
-use futures_util::future::poll_fn;
-use futures_util::{pin_mut, SinkExt, StreamExt};
+use bytes::{BufMut, Bytes, BytesMut};
+use futures::future::{ok, Either};
+use futures::{Async, Future, Poll, Sink, Stream};

 use crate::error::PayloadError;
 use crate::h1;
@ -22,15 +18,15 @@ use super::error::{ConnectError, SendRequestError};
 use super::pool::Acquired;
 use crate::body::{BodySize, MessageBody};

-pub(crate) async fn send_request<T, B>(
+pub(crate) fn send_request<T, B>(
    io: T,
    mut head: RequestHeadType,
    body: B,
    created: time::Instant,
    pool: Option<Acquired<T>>,
-) -> Result<(ResponseHead, Payload), SendRequestError>
+) -> impl Future<Item = (ResponseHead, Payload), Error = SendRequestError>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
    B: MessageBody,
 {
    // set request host header
@ -45,7 +41,7 @@ where
                Some(port) => write!(wrt, "{}:{}", host, port),
            };

-            match wrt.get_mut().split().freeze().try_into() {
+            match wrt.get_mut().take().freeze().try_into() {
                Ok(value) => match head {
                    RequestHeadType::Owned(ref mut head) => {
                        head.headers.insert(HOST, value)
@ -66,100 +62,68 @@ where
        io: Some(io),
    };

+    let len = body.size();
+
    // create Framed and send request
-    let mut framed = Framed::new(io, h1::ClientCodec::default());
-    framed.send((head, body.size()).into()).await?;
-
-    // send request body
-    match body.size() {
-        BodySize::None | BodySize::Empty | BodySize::Sized(0) => (),
-        _ => send_body(body, &mut framed).await?,
-    };
-
-    // read response and init read body
-    let res = framed.into_future().await;
-    let (head, framed) = if let (Some(result), framed) = res {
-        let item = result.map_err(SendRequestError::from)?;
-        (item, framed)
-    } else {
-        return Err(SendRequestError::from(ConnectError::Disconnected));
-    };
-
-    match framed.get_codec().message_type() {
-        h1::MessageType::None => {
-            let force_close = !framed.get_codec().keepalive();
-            release_connection(framed, force_close);
-            Ok((head, Payload::None))
-        }
-        _ => {
-            let pl: PayloadStream = PlStream::new(framed).boxed_local();
-            Ok((head, pl.into()))
-        }
-    }
+    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) async fn open_tunnel<T>(
+pub(crate) fn open_tunnel<T>(
    io: T,
    head: RequestHeadType,
-) -> Result<(ResponseHead, Framed<T, h1::ClientCodec>), SendRequestError>
+) -> impl Future<Item = (ResponseHead, Framed<T, h1::ClientCodec>), Error = SendRequestError>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
 {
    // create Framed and send request
-    let mut framed = Framed::new(io, h1::ClientCodec::default());
-    framed.send((head, BodySize::None).into()).await?;
-
-    // read response
-    if let (Some(result), framed) = framed.into_future().await {
-        let head = result.map_err(SendRequestError::from)?;
-        Ok((head, framed))
-    } else {
-        Err(SendRequestError::from(ConnectError::Disconnected))
-    }
-}
-
-/// send request body to the peer
-pub(crate) async fn send_body<I, B>(
-    body: B,
-    framed: &mut Framed<I, h1::ClientCodec>,
-) -> Result<(), SendRequestError>
-where
-    I: ConnectionLifetime,
-    B: MessageBody,
-{
-    let mut eof = false;
-    pin_mut!(body);
-    while !eof {
-        while !eof && !framed.is_write_buf_full() {
-            match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(result) => {
-                    framed.write(h1::Message::Chunk(Some(result?)))?;
-                }
-                None => {
-                    eof = true;
-                    framed.write(h1::Message::Chunk(None))?;
-                }
-            }
-        }
-
-        if !framed.is_write_buf_empty() {
-            poll_fn(|cx| match framed.flush(cx) {
-                Poll::Ready(Ok(_)) => Poll::Ready(Ok(())),
-                Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
-                Poll::Pending => {
-                    if !framed.is_write_buf_full() {
-                        Poll::Ready(Ok(()))
+    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 {
-                        Poll::Pending
+                        Err(SendRequestError::from(ConnectError::Disconnected))
                    }
-                }
-            })
-            .await?;
-        }
-    }
-
-    SinkExt::flush(framed).await?;
-    Ok(())
+                })
+        })
 }

 #[doc(hidden)]
@ -170,10 +134,7 @@ pub struct H1Connection<T> {
    pool: Option<Acquired<T>>,
 }

-impl<T> ConnectionLifetime for H1Connection<T>
-where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
-{
+impl<T: AsyncRead + AsyncWrite + 'static> ConnectionLifetime for H1Connection<T> {
    /// Close connection
    fn close(&mut self) {
        if let Some(mut pool) = self.pool.take() {
@ -201,44 +162,98 @@ where
    }
 }

-impl<T: AsyncRead + AsyncWrite + Unpin + 'static> AsyncRead for H1Connection<T> {
-    unsafe fn prepare_uninitialized_buffer(
-        &self,
-        buf: &mut [mem::MaybeUninit<u8>],
-    ) -> bool {
-        self.io.as_ref().unwrap().prepare_uninitialized_buffer(buf)
-    }
-
-    fn poll_read(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &mut [u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.io.as_mut().unwrap()).poll_read(cx, buf)
+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 + Unpin + 'static> AsyncWrite for H1Connection<T> {
-    fn poll_write(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-        buf: &[u8],
-    ) -> Poll<io::Result<usize>> {
-        Pin::new(&mut self.io.as_mut().unwrap()).poll_write(cx, 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 poll_flush(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<io::Result<()>> {
-        Pin::new(self.io.as_mut().unwrap()).poll_flush(cx)
+    fn flush(&mut self) -> io::Result<()> {
+        self.io.as_mut().unwrap().flush()
    }
+}

-    fn poll_shutdown(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Result<(), io::Error>> {
-        Pin::new(self.io.as_mut().unwrap()).poll_shutdown(cx)
+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);
+        }
    }
 }

@ -255,27 +270,23 @@ impl<Io: ConnectionLifetime> PlStream<Io> {
 }

 impl<Io: ConnectionLifetime> Stream for PlStream<Io> {
-    type Item = Result<Bytes, PayloadError>;
+    type Item = Bytes;
+    type Error = PayloadError;

-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-
-        match this.framed.as_mut().unwrap().next_item(cx)? {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(Some(chunk)) => {
+    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 {
-                    Poll::Ready(Some(Ok(chunk)))
+                    Ok(Async::Ready(Some(chunk)))
                } else {
-                    let framed = this.framed.take().unwrap();
+                    let framed = self.framed.take().unwrap();
                    let force_close = !framed.get_codec().keepalive();
                    release_connection(framed, force_close);
-                    Poll::Ready(None)
+                    Ok(Async::Ready(None))
                }
            }
-            Poll::Ready(None) => Poll::Ready(None),
+            Async::Ready(None) => Ok(Async::Ready(None)),
        }
    }
 }
--- a/actix-http/src/client/h2proto.rs
+++ b/actix-http/src/client/h2proto.rs
@ -1,37 +1,31 @@
-use std::convert::TryFrom;
-use std::future::Future;
 use std::time;

 use actix_codec::{AsyncRead, AsyncWrite};
 use bytes::Bytes;
-use futures_util::future::poll_fn;
-use futures_util::pin_mut;
-use h2::{
-    client::{Builder, Connection, SendRequest},
-    SendStream,
-};
+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, Method, Version};
+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::config::ConnectorConfig;
 use super::connection::{ConnectionType, IoConnection};
 use super::error::SendRequestError;
 use super::pool::Acquired;

-pub(crate) async fn send_request<T, B>(
-    mut io: SendRequest<Bytes>,
+pub(crate) fn send_request<T, B>(
+    io: SendRequest<Bytes>,
    head: RequestHeadType,
    body: B,
    created: time::Instant,
    pool: Option<Acquired<T>>,
-) -> Result<(ResponseHead, Payload), SendRequestError>
+) -> impl Future<Item = (ResponseHead, Payload), Error = SendRequestError>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
    B: MessageBody,
 {
    trace!("Sending client request: {:?} {:?}", head, body.size());
@ -42,137 +36,158 @@ where
        _ => false,
    };

-    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;
+    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;
+            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(),
-        ),
-    };
+            // 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),
-        ),
-    };
+            // 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());
+            // 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());
-    }
-
-    let res = poll_fn(|cx| io.poll_ready(cx)).await;
-    if let Err(e) = res {
-        release(io, pool, created, e.is_io());
-        return Err(SendRequestError::from(e));
-    }
-
-    let resp = match io.send_request(req, eof) {
-        Ok((fut, send)) => {
-            release(io, pool, created, false);
-
-            if !eof {
-                send_body(body, send).await?;
+            // 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());
            }
-            fut.await.map_err(SendRequestError::from)?
-        }
-        Err(e) => {
-            release(io, pool, created, e.is_io());
-            return Err(e.into());
-        }
-    };

-    let (parts, body) = resp.into_parts();
-    let payload = if head_req { Payload::None } else { body.into() };
+            match io.send_request(req, eof) {
+                Ok((res, send)) => {
+                    release(io, pool, created, false);

-    let mut head = ResponseHead::new(parts.status);
-    head.version = parts.version;
-    head.headers = parts.headers.into();
-    Ok((head, payload))
+                    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()
 }

-async fn send_body<B: MessageBody>(
+struct SendBody<B: MessageBody> {
    body: B,
-    mut send: SendStream<Bytes>,
-) -> Result<(), SendRequestError> {
-    let mut buf = None;
-    pin_mut!(body);
-    loop {
-        if buf.is_none() {
-            match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(Ok(b)) => {
-                    send.reserve_capacity(b.len());
-                    buf = Some(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()),
                }
-                Some(Err(e)) => return Err(e.into()),
-                None => {
-                    if let Err(e) = send.send_data(Bytes::new(), true) {
+            }
+
+            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());
-                    }
-                    send.reserve_capacity(0);
-                    return Ok(());
-                }
-            }
-        }
-
-        match poll_fn(|cx| send.poll_capacity(cx)).await {
-            None => return Ok(()),
-            Some(Ok(cap)) => {
-                let b = buf.as_mut().unwrap();
-                let len = b.len();
-                let bytes = b.split_to(std::cmp::min(cap, len));
-
-                if let Err(e) = send.send_data(bytes, false) {
-                    return Err(e.into());
-                } else {
-                    if !b.is_empty() {
-                        send.reserve_capacity(b.len());
                    } else {
-                        buf = None;
+                        if !buf.is_empty() {
+                            self.send.reserve_capacity(buf.len());
+                            self.buf = Some(buf);
+                        }
+                        continue;
                    }
-                    continue;
                }
+                Err(e) => return Err(e.into()),
            }
-            Some(Err(e)) => return Err(e.into()),
        }
    }
 }

 // release SendRequest object
-fn release<T: AsyncRead + AsyncWrite + Unpin + 'static>(
+fn release<T: AsyncRead + AsyncWrite + 'static>(
    io: SendRequest<Bytes>,
    pool: Option<Acquired<T>>,
    created: time::Instant,
@ -186,18 +201,3 @@ fn release<T: AsyncRead + AsyncWrite + Unpin + 'static>(
        }
    }
 }
-
-pub(crate) fn handshake<Io>(
-    io: Io,
-    config: &ConnectorConfig,
-) -> impl Future<Output = Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    let mut builder = Builder::new();
-    builder
-        .initial_window_size(config.stream_window_size)
-        .initial_connection_window_size(config.conn_window_size)
-        .enable_push(false);
-    builder.handshake(io)
-}
--- a/actix-http/src/client/mod.rs
+++ b/actix-http/src/client/mod.rs
@ -1,7 +1,6 @@
 //! Http client api
 use http::Uri;

-mod config;
 mod connection;
 mod connector;
 mod error;
--- a/actix-http/src/client/pool.rs
+++ b/actix-http/src/client/pool.rs
@ -1,28 +1,25 @@
 use std::cell::RefCell;
 use std::collections::VecDeque;
-use std::future::Future;
-use std::pin::Pin;
+use std::io;
 use std::rc::Rc;
-use std::task::{Context, Poll};
 use std::time::{Duration, Instant};

 use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{delay_for, Delay};
 use actix_service::Service;
-use actix_utils::{oneshot, task::LocalWaker};
 use bytes::Bytes;
-use futures_util::future::{poll_fn, FutureExt, LocalBoxFuture};
-use fxhash::FxHashMap;
-use h2::client::{Connection, SendRequest};
+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 pin_project::pin_project;
 use slab::Slab;
+use tokio_timer::{sleep, Delay};

-use super::config::ConnectorConfig;
 use super::connection::{ConnectionType, IoConnection};
 use super::error::ConnectError;
-use super::h2proto::handshake;
 use super::Connect;

 #[derive(Clone, Copy, PartialEq)]
@ -44,24 +41,37 @@ impl From<Authority> for Key {
 }

 /// Connections pool
-pub(crate) struct ConnectionPool<T, Io: 'static>(Rc<RefCell<T>>, Rc<RefCell<Inner<Io>>>);
+pub(crate) struct ConnectionPool<T, Io: AsyncRead + AsyncWrite + 'static>(
+    T,
+    Rc<RefCell<Inner<Io>>>,
+);

 impl<T, Io> ConnectionPool<T, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
+        + Clone
        + 'static,
 {
-    pub(crate) fn new(connector: T, config: ConnectorConfig) -> Self {
+    pub(crate) fn new(
+        connector: T,
+        conn_lifetime: Duration,
+        conn_keep_alive: Duration,
+        disconnect_timeout: Option<Duration>,
+        limit: usize,
+    ) -> Self {
        ConnectionPool(
-            Rc::new(RefCell::new(connector)),
+            connector,
            Rc::new(RefCell::new(Inner {
-                config,
+                conn_lifetime,
+                conn_keep_alive,
+                disconnect_timeout,
+                limit,
                acquired: 0,
                waiters: Slab::new(),
                waiters_queue: IndexSet::new(),
-                available: FxHashMap::default(),
-                waker: LocalWaker::new(),
+                available: HashMap::new(),
+                task: None,
            })),
        )
    }
@ -69,7 +79,8 @@ where

 impl<T, Io> Clone for ConnectionPool<T, Io>
 where
-    Io: 'static,
+    T: Clone,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
    fn clone(&self) -> Self {
        ConnectionPool(self.0.clone(), self.1.clone())
@ -78,161 +89,199 @@ where

 impl<T, Io> Service for ConnectionPool<T, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    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 = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>;
+    type Future = Either<
+        FutureResult<Self::Response, Self::Error>,
+        Either<WaitForConnection<Io>, OpenConnection<T::Future, Io>>,
+    >;

-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.0.poll_ready(cx)
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.0.poll_ready()
    }

    fn call(&mut self, req: Connect) -> Self::Future {
-        // start support future
-        actix_rt::spawn(ConnectorPoolSupport {
-            connector: self.0.clone(),
-            inner: self.1.clone(),
-        });
-
-        let mut connector = self.0.clone();
-        let inner = self.1.clone();
-
-        let fut = async move {
-            let key = if let Some(authority) = req.uri.authority() {
-                authority.clone().into()
-            } else {
-                return Err(ConnectError::Unresolved);
-            };
-
-            // acquire connection
-            match poll_fn(|cx| Poll::Ready(inner.borrow_mut().acquire(&key, cx))).await {
-                Acquire::Acquired(io, created) => {
-                    // use existing connection
-                    return Ok(IoConnection::new(
-                        io,
-                        created,
-                        Some(Acquired(key, Some(inner))),
-                    ));
-                }
-                Acquire::Available => {
-                    // open tcp connection
-                    let (io, proto) = connector.call(req).await?;
-
-                    let config = inner.borrow().config.clone();
-
-                    let guard = OpenGuard::new(key, inner);
-
-                    if proto == Protocol::Http1 {
-                        Ok(IoConnection::new(
-                            ConnectionType::H1(io),
-                            Instant::now(),
-                            Some(guard.consume()),
-                        ))
-                    } else {
-                        let (snd, connection) = handshake(io, &config).await?;
-                        actix_rt::spawn(connection.map(|_| ()));
-                        Ok(IoConnection::new(
-                            ConnectionType::H2(snd),
-                            Instant::now(),
-                            Some(guard.consume()),
-                        ))
-                    }
-                }
-                _ => {
-                    // connection is not available, wait
-                    let (rx, token) = inner.borrow_mut().wait_for(req);
-
-                    let guard = WaiterGuard::new(key, token, inner);
-                    let res = match rx.await {
-                        Err(_) => Err(ConnectError::Disconnected),
-                        Ok(res) => res,
-                    };
-                    guard.consume();
-                    res
-                }
-            }
+        let key = if let Some(authority) = req.uri.authority_part() {
+            authority.clone().into()
+        } else {
+            return Either::A(err(ConnectError::Unresolverd));
        };

-        fut.boxed_local()
+        // 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()),
+        }))
    }
 }

-struct WaiterGuard<Io>
+#[doc(hidden)]
+pub struct WaitForConnection<Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
    key: Key,
    token: usize,
+    rx: oneshot::Receiver<Result<IoConnection<Io>, ConnectError>>,
    inner: Option<Rc<RefCell<Inner<Io>>>>,
 }

-impl<Io> WaiterGuard<Io>
+impl<Io> Drop for WaitForConnection<Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
-{
-    fn new(key: Key, token: usize, inner: Rc<RefCell<Inner<Io>>>) -> Self {
-        Self {
-            key,
-            token,
-            inner: Some(inner),
-        }
-    }
-
-    fn consume(mut self) {
-        let _ = self.inner.take();
-    }
-}
-
-impl<Io> Drop for WaiterGuard<Io>
-where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    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_availability();
+            inner.check_availibility();
        }
    }
 }

-struct OpenGuard<Io>
+impl<Io> Future for WaitForConnection<Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    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<Io> OpenGuard<Io>
+impl<F, Io> OpenConnection<F, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    F: Future<Item = (Io, Protocol), Error = ConnectError>,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
-    fn new(key: Key, inner: Rc<RefCell<Inner<Io>>>) -> Self {
-        Self {
+    fn new(key: Key, inner: Rc<RefCell<Inner<Io>>>, fut: F) -> Self {
+        OpenConnection {
            key,
+            fut,
            inner: Some(inner),
+            h2: None,
        }
    }
-
-    fn consume(mut self) -> Acquired<Io> {
-        Acquired(self.key.clone(), self.inner.take())
-    }
 }

-impl<Io> Drop for OpenGuard<Io>
+impl<F, Io> Drop for OpenConnection<F, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
    fn drop(&mut self) {
-        if let Some(i) = self.inner.take() {
-            let mut inner = i.as_ref().borrow_mut();
+        if let Some(inner) = self.inner.take() {
+            let mut inner = inner.as_ref().borrow_mut();
            inner.release();
-            inner.check_availability();
+            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),
        }
    }
 }
@ -250,9 +299,12 @@ struct AvailableConnection<Io> {
 }

 pub(crate) struct Inner<Io> {
-    config: ConnectorConfig,
+    conn_lifetime: Duration,
+    conn_keep_alive: Duration,
+    disconnect_timeout: Option<Duration>,
+    limit: usize,
    acquired: usize,
-    available: FxHashMap<Key, VecDeque<AvailableConnection<Io>>>,
+    available: HashMap<Key, VecDeque<AvailableConnection<Io>>>,
    waiters: Slab<
        Option<(
            Connect,
@ -260,7 +312,7 @@ pub(crate) struct Inner<Io> {
        )>,
    >,
    waiters_queue: IndexSet<(Key, usize)>,
-    waker: LocalWaker,
+    task: Option<AtomicTask>,
 }

 impl<Io> Inner<Io> {
@ -280,7 +332,7 @@ impl<Io> Inner<Io> {

 impl<Io> Inner<Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
    /// connection is not available, wait
    fn wait_for(
@ -289,21 +341,22 @@ where
    ) -> (
        oneshot::Receiver<Result<IoConnection<Io>, ConnectError>>,
        usize,
+        bool,
    ) {
        let (tx, rx) = oneshot::channel();

-        let key: Key = connect.uri.authority().unwrap().clone().into();
+        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)
+        (rx, token, self.task.is_some())
    }

-    fn acquire(&mut self, key: &Key, cx: &mut Context<'_>) -> Acquire<Io> {
+    fn acquire(&mut self, key: &Key) -> Acquire<Io> {
        // check limits
-        if self.config.limit > 0 && self.acquired >= self.config.limit {
+        if self.limit > 0 && self.acquired >= self.limit {
            return Acquire::NotAvailable;
        }

@ -315,31 +368,33 @@ where
            let now = Instant::now();
            while let Some(conn) = connections.pop_back() {
                // check if it still usable
-                if (now - conn.used) > self.config.conn_keep_alive
-                    || (now - conn.created) > self.config.conn_lifetime
+                if (now - conn.used) > self.conn_keep_alive
+                    || (now - conn.created) > self.conn_lifetime
                {
-                    if let Some(timeout) = self.config.disconnect_timeout {
+                    if let Some(timeout) = self.disconnect_timeout {
                        if let ConnectionType::H1(io) = conn.io {
-                            actix_rt::spawn(CloseConnection::new(io, timeout))
+                            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 Pin::new(s).poll_read(cx, &mut buf) {
-                            Poll::Pending => (),
-                            Poll::Ready(Ok(n)) if n > 0 => {
-                                if let Some(timeout) = self.config.disconnect_timeout {
+                        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 {
-                                        actix_rt::spawn(CloseConnection::new(
-                                            io, timeout,
-                                        ))
+                                        tokio_current_thread::spawn(
+                                            CloseConnection::new(io, timeout),
+                                        )
                                    }
                                }
                                continue;
                            }
-                            _ => continue,
+                            Ok(_) | Err(_) => continue,
                        }
                    }
                    return Acquire::Acquired(io, conn.created);
@ -359,22 +414,24 @@ where
                created,
                used: Instant::now(),
            });
-        self.check_availability();
+        self.check_availibility();
    }

    fn release_close(&mut self, io: ConnectionType<Io>) {
        self.acquired -= 1;
-        if let Some(timeout) = self.config.disconnect_timeout {
+        if let Some(timeout) = self.disconnect_timeout {
            if let ConnectionType::H1(io) = io {
-                actix_rt::spawn(CloseConnection::new(io, timeout))
+                tokio_current_thread::spawn(CloseConnection::new(io, timeout))
            }
        }
-        self.check_availability();
+        self.check_availibility();
    }

-    fn check_availability(&self) {
-        if !self.waiters_queue.is_empty() && self.acquired < self.config.limit {
-            self.waker.wake();
+    fn check_availibility(&self) {
+        if !self.waiters_queue.is_empty() && self.acquired < self.limit {
+            if let Some(t) = self.task.as_ref() {
+                t.notify()
+            }
        }
    }
 }
@ -386,39 +443,37 @@ struct CloseConnection<T> {

 impl<T> CloseConnection<T>
 where
-    T: AsyncWrite + Unpin,
+    T: AsyncWrite,
 {
    fn new(io: T, timeout: Duration) -> Self {
        CloseConnection {
            io,
-            timeout: delay_for(timeout),
+            timeout: sleep(timeout),
        }
    }
 }

 impl<T> Future for CloseConnection<T>
 where
-    T: AsyncWrite + Unpin,
+    T: AsyncWrite,
 {
-    type Output = ();
+    type Item = ();
+    type Error = ();

-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-        let this = self.get_mut();
-
-        match Pin::new(&mut this.timeout).poll(cx) {
-            Poll::Ready(_) => Poll::Ready(()),
-            Poll::Pending => match Pin::new(&mut this.io).poll_shutdown(cx) {
-                Poll::Ready(_) => Poll::Ready(()),
-                Poll::Pending => Poll::Pending,
+    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),
            },
        }
    }
 }

-#[pin_project]
 struct ConnectorPoolSupport<T, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
    connector: T,
    inner: Rc<RefCell<Inner<Io>>>,
@ -426,17 +481,16 @@ where

 impl<T, Io> Future for ConnectorPoolSupport<T, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>,
    T::Future: 'static,
 {
-    type Output = ();
+    type Item = ();
+    type Error = ();

-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-
-        let mut inner = this.inner.as_ref().borrow_mut();
-        inner.waker.register(cx.waker());
+    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 {
@ -451,14 +505,14 @@ where
                continue;
            }

-            match inner.acquire(&key, cx) {
+            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(this.inner.clone()))),
+                        Some(Acquired(key.clone(), Some(self.inner.clone()))),
                    ))) {
                        let (io, created) = conn.unwrap().into_inner();
                        inner.release_conn(&key, io, created);
@ -470,131 +524,118 @@ where
                    OpenWaitingConnection::spawn(
                        key.clone(),
                        tx,
-                        this.inner.clone(),
-                        this.connector.call(connect),
-                        inner.config.clone(),
+                        self.inner.clone(),
+                        self.connector.call(connect),
                    );
                }
            }
            let _ = inner.waiters_queue.swap_remove_index(0);
        }

-        Poll::Pending
+        Ok(Async::NotReady)
    }
 }

-#[pin_project::pin_project(PinnedDrop)]
 struct OpenWaitingConnection<F, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
-    #[pin]
    fut: F,
    key: Key,
-    h2: Option<
-        LocalBoxFuture<
-            'static,
-            Result<(SendRequest<Bytes>, Connection<Io, Bytes>), h2::Error>,
-        >,
-    >,
+    h2: Option<Handshake<Io, Bytes>>,
    rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
    inner: Option<Rc<RefCell<Inner<Io>>>>,
-    config: ConnectorConfig,
 }

 impl<F, Io> OpenWaitingConnection<F, Io>
 where
-    F: Future<Output = Result<(Io, Protocol), ConnectError>> + 'static,
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    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,
-        config: ConnectorConfig,
    ) {
-        actix_rt::spawn(OpenWaitingConnection {
+        tokio_current_thread::spawn(OpenWaitingConnection {
            key,
            fut,
            h2: None,
            rx: Some(rx),
            inner: Some(inner),
-            config,
        })
    }
 }

-#[pin_project::pinned_drop]
-impl<F, Io> PinnedDrop for OpenWaitingConnection<F, Io>
+impl<F, Io> Drop for OpenWaitingConnection<F, Io>
 where
-    Io: AsyncRead + AsyncWrite + Unpin + 'static,
+    Io: AsyncRead + AsyncWrite + 'static,
 {
-    fn drop(self: Pin<&mut Self>) {
-        if let Some(inner) = self.project().inner.take() {
+    fn drop(&mut self) {
+        if let Some(inner) = self.inner.take() {
            let mut inner = inner.as_ref().borrow_mut();
            inner.release();
-            inner.check_availability();
+            inner.check_availibility();
        }
    }
 }

 impl<F, Io> Future for OpenWaitingConnection<F, Io>
 where
-    F: Future<Output = Result<(Io, Protocol), ConnectError>>,
-    Io: AsyncRead + AsyncWrite + Unpin,
+    F: Future<Item = (Io, Protocol), Error = ConnectError>,
+    Io: AsyncRead + AsyncWrite,
 {
-    type Output = ();
+    type Item = ();
+    type Error = ();

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
-
-        if let Some(ref mut h2) = this.h2 {
-            return match Pin::new(h2).poll(cx) {
-                Poll::Ready(Ok((snd, connection))) => {
-                    actix_rt::spawn(connection.map(|_| ()));
-                    let rx = this.rx.take().unwrap();
+    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(this.key.clone(), this.inner.take())),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
                    )));
-                    Poll::Ready(())
+                    Ok(Async::Ready(()))
                }
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(Err(err)) => {
-                    let _ = this.inner.take();
-                    if let Some(rx) = this.rx.take() {
+                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)));
                    }
-                    Poll::Ready(())
+                    Err(())
                }
            };
        }

-        match this.fut.poll(cx) {
-            Poll::Ready(Err(err)) => {
-                let _ = this.inner.take();
-                if let Some(rx) = this.rx.take() {
+        match self.fut.poll() {
+            Err(err) => {
+                let _ = self.inner.take();
+                if let Some(rx) = self.rx.take() {
                    let _ = rx.send(Err(err));
                }
-                Poll::Ready(())
+                Err(())
            }
-            Poll::Ready(Ok((io, proto))) => {
+            Ok(Async::Ready((io, proto))) => {
                if proto == Protocol::Http1 {
-                    let rx = this.rx.take().unwrap();
+                    let rx = self.rx.take().unwrap();
                    let _ = rx.send(Ok(IoConnection::new(
                        ConnectionType::H1(io),
                        Instant::now(),
-                        Some(Acquired(this.key.clone(), this.inner.take())),
+                        Some(Acquired(self.key.clone(), self.inner.take())),
                    )));
-                    Poll::Ready(())
+                    Ok(Async::Ready(()))
                } else {
-                    *this.h2 = Some(handshake(io, this.config).boxed_local());
-                    self.poll(cx)
+                    self.h2 = Some(handshake(io));
+                    self.poll()
                }
            }
-            Poll::Pending => Poll::Pending,
+            Ok(Async::NotReady) => Ok(Async::NotReady),
        }
    }
 }
@ -603,7 +644,7 @@ pub(crate) struct Acquired<T>(Key, Option<Rc<RefCell<Inner<T>>>>);

 impl<T> Acquired<T>
 where
-    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    T: AsyncRead + AsyncWrite + 'static,
 {
    pub(crate) fn close(&mut self, conn: IoConnection<T>) {
        if let Some(inner) = self.1.take() {
--- a/actix-http/src/cloneable.rs
+++ b/actix-http/src/cloneable.rs
@ -1,40 +1,42 @@
-use std::cell::RefCell;
+use std::cell::UnsafeCell;
 use std::rc::Rc;
-use std::task::{Context, Poll};

 use actix_service::Service;
+use futures::Poll;

 #[doc(hidden)]
 /// Service that allows to turn non-clone service to a service with `Clone` impl
-///
-/// # Panics
-/// CloneableService might panic with some creative use of thread local storage.
-/// See https://github.com/actix/actix-web/issues/1295 for example
-pub(crate) struct CloneableService<T: Service>(Rc<RefCell<T>>);
+pub(crate) struct CloneableService<T>(Rc<UnsafeCell<T>>);

-impl<T: Service> CloneableService<T> {
-    pub(crate) fn new(service: T) -> Self {
-        Self(Rc::new(RefCell::new(service)))
+impl<T> CloneableService<T> {
+    pub(crate) fn new(service: T) -> Self
+    where
+        T: Service,
+    {
+        Self(Rc::new(UnsafeCell::new(service)))
    }
 }

-impl<T: Service> Clone for CloneableService<T> {
+impl<T> Clone for CloneableService<T> {
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
 }

-impl<T: Service> Service for CloneableService<T> {
+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, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.0.borrow_mut().poll_ready(cx)
+    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 {
-        self.0.borrow_mut().call(req)
+        unsafe { &mut *self.0.as_ref().get() }.call(req)
    }
 }
--- a/actix-http/src/config.rs
+++ b/actix-http/src/config.rs
@ -1,13 +1,13 @@
-use std::cell::Cell;
+use std::cell::UnsafeCell;
+use std::fmt;
 use std::fmt::Write;
 use std::rc::Rc;
-use std::time::Duration;
-use std::{fmt, net};
+use std::time::{Duration, Instant};

-use actix_rt::time::{delay_for, delay_until, Delay, Instant};
 use bytes::BytesMut;
-use futures_util::{future, FutureExt};
-use time::OffsetDateTime;
+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;
@ -47,8 +47,6 @@ struct Inner {
    client_timeout: u64,
    client_disconnect: u64,
    ka_enabled: bool,
-    secure: bool,
-    local_addr: Option<std::net::SocketAddr>,
    timer: DateService,
 }

@ -60,7 +58,7 @@ impl Clone for ServiceConfig {

 impl Default for ServiceConfig {
    fn default() -> Self {
-        Self::new(KeepAlive::Timeout(5), 0, 0, false, None)
+        Self::new(KeepAlive::Timeout(5), 0, 0)
    }
 }

@ -70,8 +68,6 @@ impl ServiceConfig {
        keep_alive: KeepAlive,
        client_timeout: u64,
        client_disconnect: u64,
-        secure: bool,
-        local_addr: Option<net::SocketAddr>,
    ) -> ServiceConfig {
        let (keep_alive, ka_enabled) = match keep_alive {
            KeepAlive::Timeout(val) => (val as u64, true),
@ -89,24 +85,10 @@ impl ServiceConfig {
            ka_enabled,
            client_timeout,
            client_disconnect,
-            secure,
-            local_addr,
            timer: DateService::new(),
        }))
    }

-    #[inline]
-    /// Returns true if connection is secure(https)
-    pub fn secure(&self) -> bool {
-        self.0.secure
-    }
-
-    #[inline]
-    /// Returns the local address that this server is bound to.
-    pub fn local_addr(&self) -> Option<net::SocketAddr> {
-        self.0.local_addr
-    }
-
    #[inline]
    /// Keep alive duration if configured.
    pub fn keep_alive(&self) -> Option<Duration> {
@ -114,7 +96,7 @@ impl ServiceConfig {
    }

    #[inline]
-    /// Return state of connection keep-alive functionality
+    /// Return state of connection keep-alive funcitonality
    pub fn keep_alive_enabled(&self) -> bool {
        self.0.ka_enabled
    }
@ -122,10 +104,10 @@ impl ServiceConfig {
    #[inline]
    /// Client timeout for first request.
    pub fn client_timer(&self) -> Option<Delay> {
-        let delay_time = self.0.client_timeout;
-        if delay_time != 0 {
-            Some(delay_until(
-                self.0.timer.now() + Duration::from_millis(delay_time),
+        let delay = self.0.client_timeout;
+        if delay != 0 {
+            Some(Delay::new(
+                self.0.timer.now() + Duration::from_millis(delay),
            ))
        } else {
            None
@ -156,7 +138,7 @@ impl ServiceConfig {
    /// 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_until(self.0.timer.now() + ka))
+            Some(Delay::new(self.0.timer.now() + ka))
        } else {
            None
        }
@ -211,12 +193,7 @@ impl Date {
    }
    fn update(&mut self) {
        self.pos = 0;
-        write!(
-            self,
-            "{}",
-            OffsetDateTime::now_utc().format("%a, %d %b %Y %H:%M:%S GMT")
-        )
-        .unwrap();
+        write!(self, "{}", time::at_utc(time::get_time()).rfc822()).unwrap();
    }
 }

@ -233,24 +210,24 @@ impl fmt::Write for Date {
 struct DateService(Rc<DateServiceInner>);

 struct DateServiceInner {
-    current: Cell<Option<(Date, Instant)>>,
+    current: UnsafeCell<Option<(Date, Instant)>>,
 }

 impl DateServiceInner {
    fn new() -> Self {
        DateServiceInner {
-            current: Cell::new(None),
+            current: UnsafeCell::new(None),
        }
    }

    fn reset(&self) {
-        self.current.take();
+        unsafe { (&mut *self.current.get()).take() };
    }

    fn update(&self) {
        let now = Instant::now();
        let date = Date::new();
-        self.current.set(Some((date, now)));
+        *(unsafe { &mut *self.current.get() }) = Some((date, now));
    }
 }

@ -260,55 +237,54 @@ impl DateService {
    }

    fn check_date(&self) {
-        if self.0.current.get().is_none() {
+        if unsafe { (&*self.0.current.get()).is_none() } {
            self.0.update();

            // periodic date update
            let s = self.clone();
-            actix_rt::spawn(delay_for(Duration::from_millis(500)).then(move |_| {
-                s.0.reset();
-                future::ready(())
-            }));
+            tokio_current_thread::spawn(sleep(Duration::from_millis(500)).then(
+                move |_| {
+                    s.0.reset();
+                    future::ok(())
+                },
+            ));
        }
    }

    fn now(&self) -> Instant {
        self.check_date();
-        self.0.current.get().unwrap().1
+        unsafe { (&*self.0.current.get()).as_ref().unwrap().1 }
    }

    fn set_date<F: FnMut(&Date)>(&self, mut f: F) {
        self.check_date();
-        f(&self.0.current.get().unwrap().0);
+        f(&unsafe { (&*self.0.current.get()).as_ref().unwrap().0 })
    }
 }

 #[cfg(test)]
 mod tests {
    use super::*;
-
-    // Test modifying the date from within the closure
-    // passed to `set_date`
-    #[test]
-    fn test_evil_date() {
-        let service = DateService::new();
-        // Make sure that `check_date` doesn't try to spawn a task
-        service.0.update();
-        service.set_date(|_| service.0.reset());
-    }
+    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());
    }

-    #[actix_rt::test]
-    async fn test_date() {
-        let settings = ServiceConfig::new(KeepAlive::Os, 0, 0, false, None);
-        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);
+    #[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,6 +1,7 @@
 use std::borrow::Cow;

-use time::{Duration, OffsetDateTime};
+use chrono::Duration;
+use time::Tm;

 use super::{Cookie, SameSite};

@ -17,6 +18,7 @@ use super::{Cookie, SameSite};
 /// ```rust
 /// use actix_http::cookie::Cookie;
 ///
+/// # fn main() {
 /// let cookie: Cookie = Cookie::build("name", "value")
 ///     .domain("www.rust-lang.org")
 ///     .path("/")
@ -24,6 +26,7 @@ use super::{Cookie, SameSite};
 ///     .http_only(true)
 ///     .max_age(84600)
 ///     .finish();
+/// # }
 /// ```
 #[derive(Debug, Clone)]
 pub struct CookieBuilder {
@ -62,14 +65,16 @@ impl CookieBuilder {
    /// ```rust
    /// use actix_http::cookie::Cookie;
    ///
+    /// # fn main() {
    /// let c = Cookie::build("foo", "bar")
-    ///     .expires(time::OffsetDateTime::now_utc())
+    ///     .expires(time::now())
    ///     .finish();
    ///
    /// assert!(c.expires().is_some());
+    /// # }
    /// ```
    #[inline]
-    pub fn expires(mut self, when: OffsetDateTime) -> CookieBuilder {
+    pub fn expires(mut self, when: Tm) -> CookieBuilder {
        self.cookie.set_expires(when);
        self
    }
@ -81,11 +86,13 @@ impl CookieBuilder {
    /// ```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 {
@ -99,18 +106,17 @@ impl CookieBuilder {
    /// ```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 {
-        // Truncate any nanoseconds from the Duration, as they aren't represented within `Max-Age`
-        // and would cause two otherwise identical `Cookie` instances to not be equivalent to one another.
-        self.cookie
-            .set_max_age(Duration::seconds(value.whole_seconds()));
+        self.cookie.set_max_age(value);
        self
    }

@ -214,14 +220,16 @@ impl CookieBuilder {
    ///
    /// ```rust
    /// use actix_http::cookie::Cookie;
-    /// use time::Duration;
+    /// 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 {
--- a/actix-http/src/cookie/draft.rs
+++ b/actix-http/src/cookie/draft.rs
@ -10,26 +10,18 @@ use std::fmt;
 /// 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 then the cookie will be sent as
-/// normal. In some browsers, this will implicitly handle the cookie as if "Lax"
-/// and in others, "None". It's best to explicitly set the `SameSite` attribute
-/// to avoid inconsistent behavior.
-///
-/// **Note:** Depending on browser, the `Secure` attribute may be required for
-/// `SameSite` "None" cookies to be accepted.
+/// 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.
-///
-/// More info about these draft changes can be found in the draft spec:
-/// - https://tools.ietf.org/html/draft-west-cookie-incrementalism-00
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum SameSite {
    /// The "Strict" `SameSite` attribute.
    Strict,
    /// The "Lax" `SameSite` attribute.
    Lax,
-    /// The "None" `SameSite` attribute.
+    /// No `SameSite` attribute.
    None,
 }

@ -96,11 +88,11 @@ impl SameSite {
 }

 impl fmt::Display for SameSite {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            SameSite::Strict => write!(f, "Strict"),
            SameSite::Lax => write!(f, "Lax"),
-            SameSite::None => write!(f, "None"),
+            SameSite::None => Ok(()),
        }
    }
 }
--- a/actix-http/src/cookie/jar.rs
+++ b/actix-http/src/cookie/jar.rs
@ -1,7 +1,7 @@
 use std::collections::HashSet;
-use std::mem;
+use std::mem::replace;

-use time::{Duration, OffsetDateTime};
+use chrono::Duration;

 use super::delta::DeltaCookie;
 use super::Cookie;
@ -13,7 +13,7 @@ use super::secure::{Key, PrivateJar, SignedJar};
 ///
 /// 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 iterator over the changes.
+/// [delta](#method.delta) method which returns an interator over the changes.
 ///
 /// # Usage
 ///
@ -188,8 +188,9 @@ impl CookieJar {
    ///
    /// ```rust
    /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use time::Duration;
+    /// use chrono::Duration;
    ///
+    /// # fn main() {
    /// let mut jar = CookieJar::new();
    ///
    /// // Assume this cookie originally had a path of "/" and domain of "a.b".
@ -202,7 +203,8 @@ impl CookieJar {
    /// 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::zero()));
+    /// assert_eq!(delta[0].max_age(), Some(Duration::seconds(0)));
+    /// # }
    /// ```
    ///
    /// Removing a new cookie does not result in a _removal_ cookie:
@ -220,8 +222,8 @@ impl CookieJar {
    pub fn remove(&mut self, mut cookie: Cookie<'static>) {
        if self.original_cookies.contains(cookie.name()) {
            cookie.set_value("");
-            cookie.set_max_age(Duration::zero());
-            cookie.set_expires(OffsetDateTime::now_utc() - Duration::days(365));
+            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());
@ -239,8 +241,9 @@ impl CookieJar {
    ///
    /// ```rust
    /// use actix_http::cookie::{CookieJar, Cookie};
-    /// use time::Duration;
+    /// use chrono::Duration;
    ///
+    /// # fn main() {
    /// let mut jar = CookieJar::new();
    ///
    /// // Add an original cookie and a new cookie.
@ -258,6 +261,7 @@ impl CookieJar {
    /// 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());
@ -273,7 +277,7 @@ impl CookieJar {
    )]
    pub fn clear(&mut self) {
        self.delta_cookies.clear();
-        for delta in mem::take(&mut self.original_cookies) {
+        for delta in replace(&mut self.original_cookies, HashSet::new()) {
            self.remove(delta.cookie);
        }
    }
@ -303,7 +307,7 @@ impl CookieJar {
    /// // Delta contains two new cookies ("new", "yac") and a removal ("name").
    /// assert_eq!(jar.delta().count(), 3);
    /// ```
-    pub fn delta(&self) -> Delta<'_> {
+    pub fn delta(&self) -> Delta {
        Delta {
            iter: self.delta_cookies.iter(),
        }
@ -339,7 +343,7 @@ impl CookieJar {
    ///     }
    /// }
    /// ```
-    pub fn iter(&self) -> Iter<'_> {
+    pub fn iter(&self) -> Iter {
        Iter {
            delta_cookies: self
                .delta_cookies
@ -382,7 +386,7 @@ impl CookieJar {
    /// assert!(jar.get("private").is_some());
    /// ```
    #[cfg(feature = "secure-cookies")]
-    pub fn private(&mut self, key: &Key) -> PrivateJar<'_> {
+    pub fn private(&mut self, key: &Key) -> PrivateJar {
        PrivateJar::new(self, key)
    }

@ -420,7 +424,7 @@ impl CookieJar {
    /// assert!(jar.get("signed").is_some());
    /// ```
    #[cfg(feature = "secure-cookies")]
-    pub fn signed(&mut self, key: &Key) -> SignedJar<'_> {
+    pub fn signed(&mut self, key: &Key) -> SignedJar {
        SignedJar::new(self, key)
    }
 }
@ -533,8 +537,8 @@ mod test {
    #[test]
    #[cfg(feature = "secure-cookies")]
    fn delta() {
+        use chrono::Duration;
        use std::collections::HashMap;
-        use time::Duration;

        let mut c = CookieJar::new();

@ -556,7 +560,7 @@ mod test {
        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::zero()));
+        assert_eq!(names.get("original").unwrap(), &Some(Duration::seconds(0)));
    }

    #[test]
--- a/actix-http/src/cookie/mod.rs
+++ b/actix-http/src/cookie/mod.rs
@ -47,7 +47,7 @@
 //! ```

 #![doc(html_root_url = "https://docs.rs/cookie/0.11")]
-#![warn(missing_docs)]
+#![deny(missing_docs)]

 mod builder;
 mod delta;
@ -65,8 +65,9 @@ use std::borrow::Cow;
 use std::fmt;
 use std::str::FromStr;

+use chrono::Duration;
 use percent_encoding::{percent_encode, AsciiSet, CONTROLS};
-use time::{Duration, OffsetDateTime};
+use time::Tm;

 pub use self::builder::CookieBuilder;
 pub use self::draft::*;
@ -103,13 +104,13 @@ enum CookieStr {

 impl CookieStr {
    /// Retrieves the string `self` corresponds to. If `self` is derived from
-    /// indexes, the corresponding sub-slice of `string` is returned. Otherwise,
+    /// indexes, the corresponding subslice of `string` is returned. Otherwise,
    /// the concrete string is returned.
    ///
    /// # Panics
    ///
    /// Panics if `self` is an indexed string and `string` is None.
-    fn to_str<'s>(&'s self, string: Option<&'s Cow<'_, str>>) -> &'s str {
+    fn to_str<'s>(&'s self, string: Option<&'s Cow<str>>) -> &'s str {
        match *self {
            CookieStr::Indexed(i, j) => {
                let s = string.expect(
@ -171,7 +172,7 @@ pub struct Cookie<'c> {
    /// The cookie's value.
    value: CookieStr,
    /// The cookie's expiration, if any.
-    expires: Option<OffsetDateTime>,
+    expires: Option<Tm>,
    /// The cookie's maximum age, if any.
    max_age: Option<Duration>,
    /// The cookie's domain, if any.
@ -478,7 +479,7 @@ impl<'c> Cookie<'c> {
    /// assert_eq!(c.max_age(), None);
    ///
    /// let c = Cookie::parse("name=value; Max-Age=3600").unwrap();
-    /// assert_eq!(c.max_age().map(|age| age.whole_hours()), Some(1));
+    /// assert_eq!(c.max_age().map(|age| age.num_hours()), Some(1));
    /// ```
    #[inline]
    pub fn max_age(&self) -> Option<Duration> {
@ -543,10 +544,10 @@ impl<'c> Cookie<'c> {
    /// let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
    /// let cookie_str = format!("name=value; Expires={}", expire_time);
    /// let c = Cookie::parse(cookie_str).unwrap();
-    /// assert_eq!(c.expires().map(|t| t.year()), Some(2017));
+    /// assert_eq!(c.expires().map(|t| t.tm_year), Some(117));
    /// ```
    #[inline]
-    pub fn expires(&self) -> Option<OffsetDateTime> {
+    pub fn expires(&self) -> Option<Tm> {
        self.expires
    }

@ -644,13 +645,15 @@ impl<'c> Cookie<'c> {
    ///
    /// ```rust
    /// use actix_http::cookie::Cookie;
-    /// use time::Duration;
+    /// use chrono::Duration;
    ///
+    /// # fn main() {
    /// let mut c = Cookie::new("name", "value");
    /// assert_eq!(c.max_age(), None);
    ///
    /// c.set_max_age(Duration::hours(10));
    /// assert_eq!(c.max_age(), Some(Duration::hours(10)));
+    /// # }
    /// ```
    #[inline]
    pub fn set_max_age(&mut self, value: Duration) {
@ -697,19 +700,20 @@ impl<'c> Cookie<'c> {
    ///
    /// ```rust
    /// use actix_http::cookie::Cookie;
-    /// use time::{Duration, OffsetDateTime};
    ///
+    /// # fn main() {
    /// let mut c = Cookie::new("name", "value");
    /// assert_eq!(c.expires(), None);
    ///
-    /// let mut now = OffsetDateTime::now();
-    /// now += Duration::week();
+    /// let mut now = time::now();
+    /// now.tm_year += 1;
    ///
    /// c.set_expires(now);
    /// assert!(c.expires().is_some())
+    /// # }
    /// ```
    #[inline]
-    pub fn set_expires(&mut self, time: OffsetDateTime) {
+    pub fn set_expires(&mut self, time: Tm) {
        self.expires = Some(time);
    }

@ -720,8 +724,9 @@ impl<'c> Cookie<'c> {
    ///
    /// ```rust
    /// use actix_http::cookie::Cookie;
-    /// use time::Duration;
+    /// use chrono::Duration;
    ///
+    /// # fn main() {
    /// let mut c = Cookie::new("foo", "bar");
    /// assert!(c.expires().is_none());
    /// assert!(c.max_age().is_none());
@ -729,14 +734,15 @@ impl<'c> Cookie<'c> {
    /// c.make_permanent();
    /// assert!(c.expires().is_some());
    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
+    /// # }
    /// ```
    pub fn make_permanent(&mut self) {
        let twenty_years = Duration::days(365 * 20);
        self.set_max_age(twenty_years);
-        self.set_expires(OffsetDateTime::now_utc() + twenty_years);
+        self.set_expires(time::now() + twenty_years);
    }

-    fn fmt_parameters(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt_parameters(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if let Some(true) = self.http_only() {
            write!(f, "; HttpOnly")?;
        }
@ -746,7 +752,9 @@ impl<'c> Cookie<'c> {
        }

        if let Some(same_site) = self.same_site() {
-            write!(f, "; SameSite={}", same_site)?;
+            if !same_site.is_none() {
+                write!(f, "; SameSite={}", same_site)?;
+            }
        }

        if let Some(path) = self.path() {
@ -758,11 +766,11 @@ impl<'c> Cookie<'c> {
        }

        if let Some(max_age) = self.max_age() {
-            write!(f, "; Max-Age={}", max_age.whole_seconds())?;
+            write!(f, "; Max-Age={}", max_age.num_seconds())?;
        }

        if let Some(time) = self.expires() {
-            write!(f, "; Expires={}", time.format("%a, %d %b %Y %H:%M:%S GMT"))?;
+            write!(f, "; Expires={}", time.rfc822())?;
        }

        Ok(())
@ -916,10 +924,10 @@ impl<'c> Cookie<'c> {
 /// let mut c = Cookie::new("my name", "this; value?");
 /// assert_eq!(&c.encoded().to_string(), "my%20name=this%3B%20value%3F");
 /// ```
-pub struct EncodedCookie<'a, 'c>(&'a Cookie<'c>);
+pub struct EncodedCookie<'a, 'c: 'a>(&'a Cookie<'c>);

 impl<'a, 'c: 'a> fmt::Display for EncodedCookie<'a, 'c> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        // Percent-encode the name and value.
        let name = percent_encode(self.0.name().as_bytes(), USERINFO);
        let value = percent_encode(self.0.value().as_bytes(), USERINFO);
@ -944,7 +952,7 @@ impl<'c> fmt::Display for Cookie<'c> {
    ///
    /// assert_eq!(&cookie.to_string(), "foo=bar; Path=/");
    /// ```
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}={}", self.name(), self.value())?;
        self.fmt_parameters(f)
    }
@ -990,7 +998,7 @@ impl<'a, 'b> PartialEq<Cookie<'b>> for Cookie<'a> {
 #[cfg(test)]
 mod tests {
    use super::{Cookie, SameSite};
-    use time::PrimitiveDateTime;
+    use time::strptime;

    #[test]
    fn format() {
@ -1015,9 +1023,7 @@ mod tests {
        assert_eq!(&cookie.to_string(), "foo=bar; Domain=www.rust-lang.org");

        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
-        let expires = PrimitiveDateTime::parse(time_str, "%a, %d %b %Y %H:%M:%S")
-            .unwrap()
-            .assume_utc();
+        let expires = strptime(time_str, "%a, %d %b %Y %H:%M:%S %Z").unwrap();
        let cookie = Cookie::build("foo", "bar").expires(expires).finish();
        assert_eq!(
            &cookie.to_string(),
@ -1037,7 +1043,7 @@ mod tests {
        let cookie = Cookie::build("foo", "bar")
            .same_site(SameSite::None)
            .finish();
-        assert_eq!(&cookie.to_string(), "foo=bar; SameSite=None");
+        assert_eq!(&cookie.to_string(), "foo=bar");
    }

    #[test]
--- a/actix-http/src/cookie/parse.rs
+++ b/actix-http/src/cookie/parse.rs
@ -5,13 +5,11 @@ use std::error::Error;
 use std::fmt;
 use std::str::Utf8Error;

+use chrono::Duration;
 use percent_encoding::percent_decode;
-use time::Duration;

 use super::{Cookie, CookieStr, SameSite};

-use crate::time_parser;
-
 /// Enum corresponding to a parsing error.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub enum ParseError {
@ -42,7 +40,7 @@ impl ParseError {
 }

 impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
 }
@ -53,7 +51,11 @@ impl From<Utf8Error> for ParseError {
    }
 }

-impl Error for ParseError {}
+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;
@ -149,7 +151,7 @@ fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
                    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().whole_seconds());
+                        let val = cmp::min(val, Duration::max_value().num_seconds());
                        Some(Duration::seconds(val))
                    }
                    Err(_) => continue,
@ -172,8 +174,6 @@ fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
                    cookie.same_site = Some(SameSite::Strict);
                } else if v.eq_ignore_ascii_case("lax") {
                    cookie.same_site = Some(SameSite::Lax);
-                } else if v.eq_ignore_ascii_case("none") {
-                    cookie.same_site = Some(SameSite::None);
                } else {
                    // We do nothing here, for now. When/if the `SameSite`
                    // attribute becomes standard, the spec says that we should
@ -183,14 +183,16 @@ fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
                }
            }
            ("expires", Some(v)) => {
-                // Try parsing with three date formats according to
+                // 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_parser::parse_http_date(v)
-                    .or_else(|| time::parse(v, "%a, %d-%b-%Y %H:%M:%S").ok());
+                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 Some(time) = tm {
-                    cookie.expires = Some(time.assume_utc())
+                if let Ok(time) = tm {
+                    cookie.expires = Some(time)
                }
            }
            _ => {
@ -218,7 +220,8 @@ where
 #[cfg(test)]
 mod tests {
    use super::{Cookie, SameSite};
-    use time::{Duration, PrimitiveDateTime};
+    use chrono::Duration;
+    use time::strptime;

    macro_rules! assert_eq_parse {
        ($string:expr, $expected:expr) => {
@ -263,16 +266,6 @@ mod tests {
        assert_eq_parse!("foo=bar; SameSite=strict", expected);
        assert_eq_parse!("foo=bar; SameSite=STrICT", expected);
        assert_eq_parse!("foo=bar; SameSite=STRICT", expected);
-
-        let expected = Cookie::build("foo", "bar")
-            .same_site(SameSite::None)
-            .finish();
-
-        assert_eq_parse!("foo=bar; SameSite=None", expected);
-        assert_eq_parse!("foo=bar; SameSITE=None", expected);
-        assert_eq_parse!("foo=bar; SameSite=nOne", expected);
-        assert_eq_parse!("foo=bar; SameSite=NoNE", expected);
-        assert_eq_parse!("foo=bar; SameSite=NONE", expected);
    }

    #[test]
@ -388,9 +381,7 @@ mod tests {
        );

        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
-        let expires = PrimitiveDateTime::parse(time_str, "%a, %d %b %Y %H:%M:%S")
-            .unwrap()
-            .assume_utc();
+        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; \
@ -399,38 +390,13 @@ mod tests {
        );

        unexpected.set_domain("foo.com");
-        let bad_expires = PrimitiveDateTime::parse(time_str, "%a, %d %b %Y %H:%S:%M")
-            .unwrap()
-            .assume_utc();
+        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
        );
-
-        expected.set_expires(expires);
-        expected.set_same_site(SameSite::Lax);
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT; \
-             SameSite=Lax",
-            expected
-        );
-        expected.set_same_site(SameSite::Strict);
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT; \
-             SameSite=Strict",
-            expected
-        );
-        expected.set_same_site(SameSite::None);
-        assert_eq_parse!(
-            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
-             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT; \
-             SameSite=None",
-            expected
-        );
    }

    #[test]
@ -452,16 +418,8 @@ mod tests {

    #[test]
    fn do_not_panic_on_large_max_ages() {
-        let max_duration = Duration::max_value();
-        let expected = Cookie::build("foo", "bar")
-            .max_age_time(max_duration)
-            .finish();
-        let overflow_duration = max_duration
-            .checked_add(Duration::nanoseconds(1))
-            .unwrap_or(max_duration);
-        assert_eq_parse!(
-            format!(" foo=bar; Max-Age={:?}", overflow_duration.whole_seconds()),
-            expected
-        );
+        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,11 +1,13 @@
-use ring::hkdf::{Algorithm, KeyType, Prk, HKDF_SHA256};
+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 = HKDF_SHA256;
-const KEYS_INFO: &[&[u8]] = &[b"COOKIE;SIGNED:HMAC-SHA256;PRIVATE:AEAD-AES-256-GCM"];
+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.
 ///
@ -23,13 +25,6 @@ pub struct Key {
    encryption_key: [u8; PRIVATE_KEY_LEN],
 }

-impl KeyType for &Key {
-    #[inline]
-    fn len(&self) -> usize {
-        SIGNED_KEY_LEN + PRIVATE_KEY_LEN
-    }
-}
-
 impl Key {
    /// Derives new signing/encryption keys from a master key.
    ///
@ -61,30 +56,25 @@ impl Key {
            );
        }

-        // An empty `Key` structure; will be filled in with HKDF derived keys.
-        let mut output_key = Key {
-            signing_key: [0; SIGNED_KEY_LEN],
-            encryption_key: [0; PRIVATE_KEY_LEN],
-        };
-
-        // Expand the master key into two HKDF generated keys.
+        // 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];
-        let prk = Prk::new_less_safe(HKDF_DIGEST, key);
-        let okm = prk.expand(KEYS_INFO, &output_key).expect("okm expand");
-        okm.fill(&mut both_keys).expect("fill keys");
+        expand(&prk, KEYS_INFO.as_bytes(), &mut both_keys);

-        // Copy the key parts into their respective fields.
-        output_key
-            .signing_key
-            .copy_from_slice(&both_keys[..SIGNED_KEY_LEN]);
-        output_key
-            .encryption_key
-            .copy_from_slice(&both_keys[SIGNED_KEY_LEN..]);
-        output_key
+        // 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 non-deterministically.
+    /// generated nondeterministically.
    ///
    /// # Panics
    ///
@ -103,7 +93,7 @@ impl Key {
    }

    /// Attempts to generate signing/encryption keys from a secure, random
-    /// source. Keys are generated non-deterministically. If randomness cannot be
+    /// source. Keys are generated nondeterministically. If randomness cannot be
    /// retrieved from the underlying operating system, returns `None`.
    ///
    /// # Example
--- a/actix-http/src/cookie/secure/private.rs
+++ b/actix-http/src/cookie/secure/private.rs
@ -1,8 +1,8 @@
 use std::str;

 use log::warn;
-use ring::aead::{Aad, Algorithm, Nonce, AES_256_GCM};
-use ring::aead::{LessSafeKey, UnboundKey};
+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;
@ -53,14 +53,11 @@ impl<'a> PrivateJar<'a> {
        }

        let ad = Aad::from(name.as_bytes());
-        let key = LessSafeKey::new(
-            UnboundKey::new(&ALGO, &self.key).expect("matching key length"),
-        );
-        let (nonce, mut sealed) = data.split_at_mut(NONCE_LEN);
+        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 = key
-            .open_in_place(nonce, ad, &mut sealed)
+        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) {
@ -159,7 +156,7 @@ Please change it as soon as possible."

    /// Encrypts the cookie's value with
    /// authenticated encryption assuring confidentiality, integrity, and authenticity.
-    fn encrypt_cookie(&self, cookie: &mut Cookie<'_>) {
+    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);
@ -199,33 +196,30 @@ Please change it as soon as possible."

 fn encrypt_name_value(name: &[u8], value: &[u8], key: &[u8]) -> Vec<u8> {
    // Create the `SealingKey` structure.
-    let unbound = UnboundKey::new(&ALGO, key).expect("matching key length");
-    let key = LessSafeKey::new(unbound);
+    let key = SealingKey::new(ALGO, key).expect("sealing key creation");

    // Create a vec to hold the [nonce | cookie value | overhead].
-    let mut data = vec![0; NONCE_LEN + value.len() + ALGO.tag_len()];
+    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);
-    let (in_out, tag) = in_out.split_at_mut(value.len());
-    in_out.copy_from_slice(value);
-
-    // Randomly generate the nonce into the nonce piece.
    SystemRandom::new()
        .fill(nonce)
        .expect("couldn't random fill nonce");
-    let nonce = Nonce::try_assume_unique_for_key(nonce).expect("invalid `nonce` length");
+    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);
-    let ad_tag = key
-        .seal_in_place_separate_tag(nonce, ad, in_out)
-        .expect("in-place seal");

-    // Copy the tag into the tag piece.
-    tag.copy_from_slice(ad_tag.as_ref());
+    // 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
 }

--- a/actix-http/src/cookie/secure/signed.rs
+++ b/actix-http/src/cookie/secure/signed.rs
@ -1,11 +1,12 @@
-use ring::hmac::{self, sign, verify};
+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: hmac::Algorithm = hmac::HMAC_SHA256;
+static HMAC_DIGEST: &Algorithm = &SHA256;
 const BASE64_DIGEST_LEN: usize = 44;
 pub const KEY_LEN: usize = 32;

@ -20,7 +21,7 @@ pub const KEY_LEN: usize = 32;
 /// This type is only available when the `secure` feature is enabled.
 pub struct SignedJar<'a> {
    parent: &'a mut CookieJar,
-    key: hmac::Key,
+    key: SigningKey,
 }

 impl<'a> SignedJar<'a> {
@ -31,7 +32,7 @@ impl<'a> SignedJar<'a> {
    pub fn new(parent: &'a mut CookieJar, key: &Key) -> SignedJar<'a> {
        SignedJar {
            parent,
-            key: hmac::Key::new(HMAC_DIGEST, key.signing()),
+            key: SigningKey::new(HMAC_DIGEST, key.signing()),
        }
    }

@ -129,7 +130,7 @@ impl<'a> SignedJar<'a> {
    }

    /// Signs the cookie's value assuring integrity and authenticity.
-    fn sign_cookie(&self, cookie: &mut Cookie<'_>) {
+    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());
--- a/actix-http/src/encoding/decoder.rs
+++ b/actix-http/src/encoding/decoder.rs
@ -1,13 +1,12 @@
-use std::future::Future;
 use std::io::{self, Write};
-use std::pin::Pin;
-use std::task::{Context, Poll};

 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_core::{ready, Stream};
+use futures::{try_ready, Async, Future, Poll, Stream};

 use super::Writer;
 use crate::error::PayloadError;
@ -24,18 +23,21 @@ pub struct Decoder<S> {

 impl<S> Decoder<S>
 where
-    S: Stream<Item = Result<Bytes, PayloadError>>,
+    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()),
            ))),
@ -69,40 +71,34 @@ where

 impl<S> Stream for Decoder<S>
 where
-    S: Stream<Item = Result<Bytes, PayloadError>> + Unpin,
+    S: Stream<Item = Bytes, Error = PayloadError>,
 {
-    type Item = Result<Bytes, PayloadError>;
+    type Item = Bytes;
+    type Error = PayloadError;

-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
        loop {
            if let Some(ref mut fut) = self.fut {
-                let (chunk, decoder) = match ready!(Pin::new(fut).poll(cx)) {
-                    Ok(item) => item,
-                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
-                };
+                let (chunk, decoder) = try_ready!(fut.poll());
                self.decoder = Some(decoder);
                self.fut.take();
                if let Some(chunk) = chunk {
-                    return Poll::Ready(Some(Ok(chunk)));
+                    return Ok(Async::Ready(Some(chunk)));
                }
            }

            if self.eof {
-                return Poll::Ready(None);
+                return Ok(Async::Ready(None));
            }

-            match Pin::new(&mut self.stream).poll_next(cx) {
-                Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(err))),
-                Poll::Ready(Some(Ok(chunk))) => {
+            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 Poll::Ready(Some(Ok(chunk)));
+                                return Ok(Async::Ready(Some(chunk)));
                            }
                        } else {
                            self.fut = Some(run(move || {
@ -112,40 +108,41 @@ where
                        }
                        continue;
                    } else {
-                        return Poll::Ready(Some(Ok(chunk)));
+                        return Ok(Async::Ready(Some(chunk)));
                    }
                }
-                Poll::Ready(None) => {
+                Async::Ready(None) => {
                    self.eof = true;
                    return if let Some(mut decoder) = self.decoder.take() {
-                        match decoder.feed_eof() {
-                            Ok(Some(res)) => Poll::Ready(Some(Ok(res))),
-                            Ok(None) => Poll::Ready(None),
-                            Err(err) => Poll::Ready(Some(Err(err.into()))),
-                        }
+                        Ok(Async::Ready(decoder.feed_eof()?))
                    } else {
-                        Poll::Ready(None)
+                        Ok(Async::Ready(None))
                    };
                }
-                Poll::Pending => break,
+                Async::NotReady => break,
            }
        }
-        Poll::Pending
+        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 {
-            ContentDecoder::Br(ref mut decoder) => match decoder.flush() {
-                Ok(()) => {
-                    let b = decoder.get_mut().take();
+            #[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 {
@ -154,6 +151,7 @@ impl ContentDecoder {
                }
                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();
@ -165,6 +163,7 @@ impl ContentDecoder {
                }
                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();
@ -176,11 +175,14 @@ impl ContentDecoder {
                }
                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()?;
@ -193,6 +195,7 @@ impl ContentDecoder {
                }
                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()?;
@ -205,6 +208,7 @@ impl ContentDecoder {
                }
                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()?;
@ -217,6 +221,7 @@ impl ContentDecoder {
                }
                Err(e) => Err(e),
            },
+            _ => Ok(Some(data)),
        }
    }
 }
--- a/actix-http/src/encoding/encoder.rs
+++ b/actix-http/src/encoding/encoder.rs
@ -1,29 +1,25 @@
 //! Stream encoder
-use std::future::Future;
 use std::io::{self, Write};
-use std::pin::Pin;
-use std::task::{Context, Poll};

 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_core::ready;
-use pin_project::{pin_project, project};
+use futures::{Async, Future, Poll};

 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
-use crate::http::{HeaderValue, StatusCode};
+use crate::http::{HeaderValue, HttpTryFrom, StatusCode};
 use crate::{Error, ResponseHead};

 use super::Writer;

-const INPLACE: usize = 1024;
+const INPLACE: usize = 2049;

-#[pin_project]
 pub struct Encoder<B> {
    eof: bool,
-    #[pin]
    body: EncoderBody<B>,
    encoder: Option<ContentEncoder>,
    fut: Option<CpuFuture<ContentEncoder, io::Error>>,
@ -79,110 +75,86 @@ impl<B: MessageBody> Encoder<B> {
    }
 }

-#[pin_project]
 enum EncoderBody<B> {
    Bytes(Bytes),
-    Stream(#[pin] B),
-    BoxedStream(Box<dyn MessageBody + Unpin>),
-}
-
-impl<B: MessageBody> MessageBody for EncoderBody<B> {
-    fn size(&self) -> BodySize {
-        match self {
-            EncoderBody::Bytes(ref b) => b.size(),
-            EncoderBody::Stream(ref b) => b.size(),
-            EncoderBody::BoxedStream(ref b) => b.size(),
-        }
-    }
-
-    #[project]
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        #[project]
-        match self.project() {
-            EncoderBody::Bytes(b) => {
-                if b.is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(std::mem::take(b))))
-                }
-            }
-            EncoderBody::Stream(b) => b.poll_next(cx),
-            EncoderBody::BoxedStream(ref mut b) => Pin::new(b.as_mut()).poll_next(cx),
-        }
-    }
+    Stream(B),
+    BoxedStream(Box<dyn MessageBody>),
 }

 impl<B: MessageBody> MessageBody for Encoder<B> {
    fn size(&self) -> BodySize {
        if self.encoder.is_none() {
-            self.body.size()
+            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(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        let mut this = self.project();
+    fn poll_next(&mut self) -> Poll<Option<Bytes>, Error> {
        loop {
-            if *this.eof {
-                return Poll::Ready(None);
+            if self.eof {
+                return Ok(Async::Ready(None));
            }

-            if let Some(ref mut fut) = this.fut {
-                let mut encoder = match ready!(Pin::new(fut).poll(cx)) {
-                    Ok(item) => item,
-                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
-                };
+            if let Some(ref mut fut) = self.fut {
+                let mut encoder = futures::try_ready!(fut.poll());
                let chunk = encoder.take();
-                *this.encoder = Some(encoder);
-                this.fut.take();
+                self.encoder = Some(encoder);
+                self.fut.take();
                if !chunk.is_empty() {
-                    return Poll::Ready(Some(Ok(chunk)));
+                    return Ok(Async::Ready(Some(chunk)));
                }
            }

-            let result = this.body.as_mut().poll_next(cx);
-
+            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 {
-                Poll::Ready(Some(Ok(chunk))) => {
-                    if let Some(mut encoder) = this.encoder.take() {
+                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();
-                            *this.encoder = Some(encoder);
+                            self.encoder = Some(encoder);
                            if !chunk.is_empty() {
-                                return Poll::Ready(Some(Ok(chunk)));
+                                return Ok(Async::Ready(Some(chunk)));
                            }
                        } else {
-                            *this.fut = Some(run(move || {
+                            self.fut = Some(run(move || {
                                encoder.write(&chunk)?;
                                Ok(encoder)
                            }));
                        }
                    } else {
-                        return Poll::Ready(Some(Ok(chunk)));
+                        return Ok(Async::Ready(Some(chunk)));
                    }
                }
-                Poll::Ready(None) => {
-                    if let Some(encoder) = this.encoder.take() {
+                Async::Ready(None) => {
+                    if let Some(encoder) = self.encoder.take() {
                        let chunk = encoder.finish()?;
                        if chunk.is_empty() {
-                            return Poll::Ready(None);
+                            return Ok(Async::Ready(None));
                        } else {
-                            *this.eof = true;
-                            return Poll::Ready(Some(Ok(chunk)));
+                            self.eof = true;
+                            return Ok(Async::Ready(Some(chunk)));
                        }
                    } else {
-                        return Poll::Ready(None);
+                        return Ok(Async::Ready(None));
                    }
                }
-                val => return val,
            }
        }
    }
@ -191,27 +163,33 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
 fn update_head(encoding: ContentEncoding, head: &mut ResponseHead) {
    head.headers_mut().insert(
        CONTENT_ENCODING,
-        HeaderValue::from_static(encoding.as_str()),
+        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)))
            }
@ -222,22 +200,28 @@ impl ContentEncoder {
    #[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),
@ -247,6 +231,7 @@ impl ContentEncoder {

    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) => {
@ -254,6 +239,7 @@ impl ContentEncoder {
                    Err(err)
                }
            },
+            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
            ContentEncoder::Gzip(ref mut encoder) => match encoder.write_all(data) {
                Ok(_) => Ok(()),
                Err(err) => {
@ -261,6 +247,7 @@ impl ContentEncoder {
                    Err(err)
                }
            },
+            #[cfg(any(feature = "flate2-zlib", feature = "flate2-rust"))]
            ContentEncoder::Deflate(ref mut encoder) => match encoder.write_all(data) {
                Ok(_) => Ok(()),
                Err(err) => {
--- a/actix-http/src/encoding/mod.rs
+++ b/actix-http/src/encoding/mod.rs
@ -19,9 +19,8 @@ impl Writer {
            buf: BytesMut::with_capacity(8192),
        }
    }
-
    fn take(&mut self) -> Bytes {
-        self.buf.split().freeze()
+        self.buf.take().freeze()
    }
 }

@ -30,7 +29,6 @@ impl io::Write for Writer {
        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
@ -1,28 +1,29 @@
 //! Error and Result module
+use std::any::TypeId;
 use std::cell::RefCell;
 use std::io::Write;
 use std::str::Utf8Error;
 use std::string::FromUtf8Error;
 use std::{fmt, io, result};

-use actix_codec::{Decoder, Encoder};
 pub use actix_threadpool::BlockingError;
-use actix_utils::framed::DispatcherError as FramedDispatcherError;
 use actix_utils::timeout::TimeoutError;
 use bytes::BytesMut;
 use derive_more::{Display, From};
-pub use futures_channel::oneshot::Canceled;
+use futures::Canceled;
 use http::uri::InvalidUri;
 use http::{header, Error as HttpError, StatusCode};
+use httparse;
 use serde::de::value::Error as DeError;
 use serde_json::error::Error as JsonError;
 use serde_urlencoded::ser::Error as FormError;
+use tokio_timer::Error as TimerError;

-// re-export for convenience
+// re-export for convinience
 use crate::body::Body;
 pub use crate::cookie::ParseError as CookieParseError;
 use crate::helpers::Writer;
-use crate::response::{Response, ResponseBuilder};
+use crate::response::Response;

 /// A specialized [`Result`](https://doc.rust-lang.org/std/result/enum.Result.html)
 /// for actix web operations
@ -34,7 +35,7 @@ pub type Result<T, E = Error> = result::Result<T, E>;

 /// General purpose actix web error.
 ///
-/// An actix web error is used to carry errors from `std::error`
+/// An actix web error is used to carry errors from `failure` or `std::error`
 /// through actix in a convenient way.  It can be created through
 /// converting errors with `into()`.
 ///
@ -60,18 +61,16 @@ impl Error {

 /// Error that can be converted to `Response`
 pub trait ResponseError: fmt::Debug + fmt::Display {
-    /// Response's status code
-    ///
-    /// Internal server error is generated by default.
-    fn status_code(&self) -> StatusCode {
-        StatusCode::INTERNAL_SERVER_ERROR
-    }
-
    /// Create response for error
    ///
    /// Internal server error is generated by default.
    fn error_response(&self) -> Response {
-        let mut resp = Response::new(self.status_code());
+        Response::new(StatusCode::INTERNAL_SERVER_ERROR)
+    }
+
+    /// Constructs an error response
+    fn render_response(&self) -> Response {
+        let mut resp = self.error_response();
        let mut buf = BytesMut::new();
        let _ = write!(Writer(&mut buf), "{}", self);
        resp.headers_mut().insert(
@ -81,30 +80,35 @@ pub trait ResponseError: fmt::Debug + fmt::Display {
        resp.set_body(Body::from(buf))
    }

-    downcast_get_type_id!();
+    #[doc(hidden)]
+    fn __private_get_type_id__(&self) -> TypeId
+    where
+        Self: 'static,
+    {
+        TypeId::of::<Self>()
+    }
 }

-downcast!(ResponseError);
+impl dyn ResponseError + 'static {
+    /// Downcasts a response error to a specific type.
+    pub fn downcast_ref<T: ResponseError + 'static>(&self) -> Option<&T> {
+        if self.__private_get_type_id__() == TypeId::of::<T>() {
+            unsafe { Some(&*(self as *const dyn ResponseError as *const T)) }
+        } else {
+            None
+        }
+    }
+}

 impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.cause, f)
    }
 }

 impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", &self.cause)
-    }
-}
-
-impl std::error::Error for Error {
-    fn cause(&self) -> Option<&dyn std::error::Error> {
-        None
-    }
-
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        None
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(f, "{:?}", &self.cause)
    }
 }

@ -114,6 +118,20 @@ impl From<()> for Error {
    }
 }

+impl std::error::Error for Error {
+    fn description(&self) -> &str {
+        "actix-http::Error"
+    }
+
+    fn cause(&self) -> Option<&dyn std::error::Error> {
+        None
+    }
+
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        None
+    }
+}
+
 impl From<std::convert::Infallible> for Error {
    fn from(_: std::convert::Infallible) -> Self {
        // `std::convert::Infallible` indicates an error
@ -138,26 +156,12 @@ impl<T: ResponseError + 'static> From<T> for Error {
    }
 }

-/// Convert Response to a Error
-impl From<Response> for Error {
-    fn from(res: Response) -> Error {
-        InternalError::from_response("", res).into()
-    }
-}
-
-/// Convert ResponseBuilder to a Error
-impl From<ResponseBuilder> for Error {
-    fn from(mut res: ResponseBuilder) -> Error {
-        InternalError::from_response("", res.finish()).into()
-    }
-}
-
 /// Return `GATEWAY_TIMEOUT` for `TimeoutError`
 impl<E: ResponseError> ResponseError for TimeoutError<E> {
-    fn status_code(&self) -> StatusCode {
+    fn error_response(&self) -> Response {
        match self {
-            TimeoutError::Service(e) => e.status_code(),
-            TimeoutError::Timeout => StatusCode::GATEWAY_TIMEOUT,
+            TimeoutError::Service(e) => e.error_response(),
+            TimeoutError::Timeout => Response::new(StatusCode::GATEWAY_TIMEOUT),
        }
    }
 }
@ -175,31 +179,31 @@ impl ResponseError for JsonError {}
 /// `InternalServerError` for `FormError`
 impl ResponseError for FormError {}

-#[cfg(feature = "openssl")]
-/// `InternalServerError` for `openssl::ssl::Error`
-impl ResponseError for actix_connect::ssl::openssl::SslError {}
+/// `InternalServerError` for `TimerError`
+impl ResponseError for TimerError {}

-#[cfg(feature = "openssl")]
+#[cfg(feature = "ssl")]
+/// `InternalServerError` for `openssl::ssl::Error`
+impl ResponseError for openssl::ssl::Error {}
+
+#[cfg(feature = "ssl")]
 /// `InternalServerError` for `openssl::ssl::HandshakeError`
-impl<T: std::fmt::Debug> ResponseError for actix_tls::openssl::HandshakeError<T> {}
+impl ResponseError for openssl::ssl::HandshakeError<tokio_tcp::TcpStream> {}

 /// Return `BAD_REQUEST` for `de::value::Error`
 impl ResponseError for DeError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+    fn error_response(&self) -> Response {
+        Response::new(StatusCode::BAD_REQUEST)
    }
 }

-/// `InternalServerError` for `Canceled`
-impl ResponseError for Canceled {}
-
 /// `InternalServerError` for `BlockingError`
 impl<E: fmt::Debug> ResponseError for BlockingError<E> {}

 /// Return `BAD_REQUEST` for `Utf8Error`
 impl ResponseError for Utf8Error {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+    fn error_response(&self) -> Response {
+        Response::new(StatusCode::BAD_REQUEST)
    }
 }

@ -209,22 +213,32 @@ impl ResponseError for HttpError {}

 /// Return `InternalServerError` for `io::Error`
 impl ResponseError for io::Error {
-    fn status_code(&self) -> StatusCode {
+    fn error_response(&self) -> Response {
        match self.kind() {
-            io::ErrorKind::NotFound => StatusCode::NOT_FOUND,
-            io::ErrorKind::PermissionDenied => StatusCode::FORBIDDEN,
-            _ => StatusCode::INTERNAL_SERVER_ERROR,
+            io::ErrorKind::NotFound => Response::new(StatusCode::NOT_FOUND),
+            io::ErrorKind::PermissionDenied => Response::new(StatusCode::FORBIDDEN),
+            _ => Response::new(StatusCode::INTERNAL_SERVER_ERROR),
        }
    }
 }

 /// `BadRequest` for `InvalidHeaderValue`
 impl ResponseError for header::InvalidHeaderValue {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+    fn error_response(&self) -> Response {
+        Response::new(StatusCode::BAD_REQUEST)
    }
 }

+/// `BadRequest` for `InvalidHeaderValue`
+impl ResponseError for header::InvalidHeaderValueBytes {
+    fn error_response(&self) -> Response {
+        Response::new(StatusCode::BAD_REQUEST)
+    }
+}
+
+/// `InternalServerError` for `futures::Canceled`
+impl ResponseError for Canceled {}
+
 /// A set of errors that can occur during parsing HTTP streams
 #[derive(Debug, Display)]
 pub enum ParseError {
@ -264,8 +278,8 @@ pub enum ParseError {

 /// Return `BadRequest` for `ParseError`
 impl ResponseError for ParseError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+    fn error_response(&self) -> Response {
+        Response::new(StatusCode::BAD_REQUEST)
    }
 }

@ -333,8 +347,6 @@ pub enum PayloadError {
    Io(io::Error),
 }

-impl std::error::Error for PayloadError {}
-
 impl From<h2::Error> for PayloadError {
    fn from(err: h2::Error) -> Self {
        PayloadError::Http2Payload(err)
@ -359,7 +371,7 @@ impl From<BlockingError<io::Error>> for PayloadError {
            BlockingError::Error(e) => PayloadError::Io(e),
            BlockingError::Canceled => PayloadError::Io(io::Error::new(
                io::ErrorKind::Other,
-                "Operation is canceled",
+                "Thread pool is gone",
            )),
        }
    }
@ -370,18 +382,18 @@ impl From<BlockingError<io::Error>> for PayloadError {
 /// - `Overflow` returns `PayloadTooLarge`
 /// - Other errors returns `BadRequest`
 impl ResponseError for PayloadError {
-    fn status_code(&self) -> StatusCode {
+    fn error_response(&self) -> Response {
        match *self {
-            PayloadError::Overflow => StatusCode::PAYLOAD_TOO_LARGE,
-            _ => StatusCode::BAD_REQUEST,
+            PayloadError::Overflow => Response::new(StatusCode::PAYLOAD_TOO_LARGE),
+            _ => Response::new(StatusCode::BAD_REQUEST),
        }
    }
 }

 /// Return `BadRequest` for `cookie::ParseError`
 impl ResponseError for crate::cookie::ParseError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+    fn error_response(&self) -> Response {
+        Response::new(StatusCode::BAD_REQUEST)
    }
 }

@ -432,7 +444,7 @@ pub enum DispatchError {
    Unknown,
 }

-/// A set of error that can occur during parsing content type
+/// A set of error that can occure during parsing content type
 #[derive(PartialEq, Debug, Display)]
 pub enum ContentTypeError {
    /// Can not parse content type
@ -443,23 +455,13 @@ pub enum ContentTypeError {
    UnknownEncoding,
 }

-impl std::error::Error for ContentTypeError {}
-
 /// Return `BadRequest` for `ContentTypeError`
 impl ResponseError for ContentTypeError {
-    fn status_code(&self) -> StatusCode {
-        StatusCode::BAD_REQUEST
+    fn error_response(&self) -> Response {
+        Response::new(StatusCode::BAD_REQUEST)
    }
 }

-impl<E, U: Encoder + Decoder> ResponseError for FramedDispatcherError<E, U>
-where
-    E: fmt::Debug + fmt::Display,
-    <U as Encoder>::Error: fmt::Debug,
-    <U as Decoder>::Error: fmt::Debug,
-{
-}
-
 /// Helper type that can wrap any error and generate custom response.
 ///
 /// In following example any `io::Error` will be converted into "BAD REQUEST"
@ -467,12 +469,14 @@ where
 /// default.
 ///
 /// ```rust
+/// # extern crate actix_http;
 /// # use std::io;
 /// # use actix_http::*;
 ///
 /// fn index(req: Request) -> Result<&'static str> {
 ///     Err(error::ErrorBadRequest(io::Error::new(io::ErrorKind::Other, "error")))
 /// }
+/// # fn main() {}
 /// ```
 pub struct InternalError<T> {
    cause: T,
@ -506,7 +510,7 @@ impl<T> fmt::Debug for InternalError<T>
 where
    T: fmt::Debug + 'static,
 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self.cause, f)
    }
 }
@ -515,7 +519,7 @@ impl<T> fmt::Display for InternalError<T>
 where
    T: fmt::Display + 'static,
 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.cause, f)
    }
 }
@ -524,19 +528,6 @@ impl<T> ResponseError for InternalError<T>
 where
    T: fmt::Debug + fmt::Display + 'static,
 {
-    fn status_code(&self) -> StatusCode {
-        match self.status {
-            InternalErrorType::Status(st) => st,
-            InternalErrorType::Response(ref resp) => {
-                if let Some(resp) = resp.borrow().as_ref() {
-                    resp.head().status
-                } else {
-                    StatusCode::INTERNAL_SERVER_ERROR
-                }
-            }
-        }
-    }
-
    fn error_response(&self) -> Response {
        match self.status {
            InternalErrorType::Status(st) => {
@ -558,6 +549,18 @@ where
            }
        }
    }
+
+    /// Constructs an error response
+    fn render_response(&self) -> Response {
+        self.error_response()
+    }
+}
+
+/// Convert Response to a Error
+impl From<Response> for Error {
+    fn from(res: Response) -> Error {
+        InternalError::from_response("", res).into()
+    }
 }

 /// Helper function that creates wrapper of any error and generate *BAD
@ -950,21 +953,24 @@ where
    InternalError::new(err, StatusCode::NETWORK_AUTHENTICATION_REQUIRED).into()
 }

-#[cfg(feature = "actors")]
-/// `InternalServerError` for `actix::MailboxError`
-/// This is supported on feature=`actors` only
-impl ResponseError for actix::MailboxError {}
+#[cfg(feature = "fail")]
+mod failure_integration {
+    use super::*;

-#[cfg(feature = "actors")]
-/// `InternalServerError` for `actix::ResolverError`
-/// This is supported on feature=`actors` only
-impl ResponseError for actix::actors::resolver::ResolverError {}
+    /// Compatibility for `failure::Error`
+    impl ResponseError for failure::Error {
+        fn error_response(&self) -> Response {
+            Response::new(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}

 #[cfg(test)]
 mod tests {
    use super::*;
    use http::{Error as HttpError, StatusCode};
    use httparse;
+    use std::error::Error as StdError;
    use std::io;

    #[test]
@ -993,7 +999,7 @@ mod tests {
    #[test]
    fn test_error_cause() {
        let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let desc = orig.to_string();
+        let desc = orig.description().to_owned();
        let e = Error::from(orig);
        assert_eq!(format!("{}", e.as_response_error()), desc);
    }
@ -1001,7 +1007,7 @@ mod tests {
    #[test]
    fn test_error_display() {
        let orig = io::Error::new(io::ErrorKind::Other, "other");
-        let desc = orig.to_string();
+        let desc = orig.description().to_owned();
        let e = Error::from(orig);
        assert_eq!(format!("{}", e), desc);
    }
@ -1043,7 +1049,7 @@ mod tests {
            match ParseError::from($from) {
                e @ $error => {
                    let desc = format!("{}", e);
-                    assert_eq!(desc, format!("IO error: {}", $from));
+                    assert_eq!(desc, format!("IO error: {}", $from.description()));
                }
                _ => unreachable!("{:?}", $from),
            }
--- a/actix-http/src/extensions.rs
+++ b/actix-http/src/extensions.rs
@ -1,14 +1,12 @@
 use std::any::{Any, TypeId};
 use std::fmt;

-use fxhash::FxHashMap;
+use hashbrown::HashMap;

 #[derive(Default)]
 /// A type map of request extensions.
 pub struct Extensions {
-    /// Use FxHasher with a std HashMap with for faster
-    /// lookups on the small `TypeId` (u64 equivalent) keys.
-    map: FxHashMap<TypeId, Box<dyn Any>>,
+    map: HashMap<TypeId, Box<dyn Any>>,
 }

 impl Extensions {
@ -16,7 +14,7 @@ impl Extensions {
    #[inline]
    pub fn new() -> Extensions {
        Extensions {
-            map: FxHashMap::default(),
+            map: HashMap::default(),
        }
    }

@ -30,30 +28,33 @@ impl Extensions {

    /// Check if container contains entry
    pub fn contains<T: 'static>(&self) -> bool {
-        self.map.contains_key(&TypeId::of::<T>())
+        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.downcast_ref())
+            .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| boxed.downcast_mut())
+            .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.downcast().ok().map(|boxed| *boxed))
+        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.
@ -64,118 +65,27 @@ impl Extensions {
 }

 impl fmt::Debug for Extensions {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Extensions").finish()
    }
 }

-#[cfg(test)]
-mod tests {
-    use super::*;
-    
-    #[test]
-    fn test_remove() {
-        let mut map = Extensions::new();
+#[test]
+fn test_extensions() {
+    #[derive(Debug, PartialEq)]
+    struct MyType(i32);

-        map.insert::<i8>(123);
-        assert!(map.get::<i8>().is_some());
+    let mut extensions = Extensions::new();

-        map.remove::<i8>();
-        assert!(map.get::<i8>().is_none());
-    }
+    extensions.insert(5i32);
+    extensions.insert(MyType(10));

-    #[test]
-    fn test_clear() {
-        let mut map = Extensions::new();
+    assert_eq!(extensions.get(), Some(&5i32));
+    assert_eq!(extensions.get_mut(), Some(&mut 5i32));

-        map.insert::<i8>(8);
-        map.insert::<i16>(16);
-        map.insert::<i32>(32);
+    assert_eq!(extensions.remove::<i32>(), Some(5i32));
+    assert!(extensions.get::<i32>().is_none());

-        assert!(map.contains::<i8>());
-        assert!(map.contains::<i16>());
-        assert!(map.contains::<i32>());
-
-        map.clear();
-
-        assert!(!map.contains::<i8>());
-        assert!(!map.contains::<i16>());
-        assert!(!map.contains::<i32>());
-
-        map.insert::<i8>(10);
-        assert_eq!(*map.get::<i8>().unwrap(), 10);
-    }
-
-    #[test]
-    fn test_integers() {
-        let mut map = Extensions::new();
-
-        map.insert::<i8>(8);
-        map.insert::<i16>(16);
-        map.insert::<i32>(32);
-        map.insert::<i64>(64);
-        map.insert::<i128>(128);
-        map.insert::<u8>(8);
-        map.insert::<u16>(16);
-        map.insert::<u32>(32);
-        map.insert::<u64>(64);
-        map.insert::<u128>(128);
-        assert!(map.get::<i8>().is_some());
-        assert!(map.get::<i16>().is_some());
-        assert!(map.get::<i32>().is_some());
-        assert!(map.get::<i64>().is_some());
-        assert!(map.get::<i128>().is_some());
-        assert!(map.get::<u8>().is_some());
-        assert!(map.get::<u16>().is_some());
-        assert!(map.get::<u32>().is_some());
-        assert!(map.get::<u64>().is_some());
-        assert!(map.get::<u128>().is_some());
-    }
-
-    #[test]
-    fn test_composition() {
-        struct Magi<T>(pub T);
-
-        struct Madoka {
-            pub god: bool,
-        }
-
-        struct Homura {
-            pub attempts: usize,
-        }
-
-        struct Mami {
-            pub guns: usize,
-        }
-
-        let mut map = Extensions::new();
-
-        map.insert(Magi(Madoka { god: false }));
-        map.insert(Magi(Homura { attempts: 0 }));
-        map.insert(Magi(Mami { guns: 999 }));
-
-        assert!(!map.get::<Magi<Madoka>>().unwrap().0.god);
-        assert_eq!(0, map.get::<Magi<Homura>>().unwrap().0.attempts);
-        assert_eq!(999, map.get::<Magi<Mami>>().unwrap().0.guns);
-    }
-
-    #[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)));
-    }
+    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,8 +1,13 @@
-use std::io;
+#![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::{Bytes, BytesMut};
+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};
@ -11,7 +16,11 @@ use super::{Message, MessageType};
 use crate::body::BodySize;
 use crate::config::ServiceConfig;
 use crate::error::{ParseError, PayloadError};
-use crate::message::{ConnectionType, RequestHeadType, ResponseHead};
+use crate::header::HeaderMap;
+use crate::helpers;
+use crate::message::{
+    ConnectionType, Head, MessagePool, RequestHead, RequestHeadType, ResponseHead,
+};

 bitflags! {
    struct Flags: u8 {
@ -21,6 +30,8 @@ bitflags! {
    }
 }

+const AVERAGE_HEADER_SIZE: usize = 30;
+
 /// HTTP/1 Codec
 pub struct ClientCodec {
    inner: ClientCodecInner,
@ -40,6 +51,7 @@ struct ClientCodecInner {

    // encoder part
    flags: Flags,
+    headers_size: u32,
    encoder: encoder::MessageEncoder<RequestHeadType>,
 }

@ -68,6 +80,7 @@ impl ClientCodec {
                ctype: ConnectionType::Close,

                flags,
+                headers_size: 0,
                encoder: encoder::MessageEncoder::default(),
            },
        }
--- a/actix-http/src/h1/codec.rs
+++ b/actix-http/src/h1/codec.rs
@ -1,9 +1,12 @@
-use std::{fmt, io};
+#![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::BytesMut;
-use http::{Method, Version};
+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};
@ -11,7 +14,8 @@ use super::{Message, MessageType};
 use crate::body::BodySize;
 use crate::config::ServiceConfig;
 use crate::error::ParseError;
-use crate::message::ConnectionType;
+use crate::helpers;
+use crate::message::{ConnectionType, Head, ResponseHead};
 use crate::request::Request;
 use crate::response::Response;

@ -23,6 +27,8 @@ bitflags! {
    }
 }

+const AVERAGE_HEADER_SIZE: usize = 30;
+
 /// HTTP/1 Codec
 pub struct Codec {
    config: ServiceConfig,
@ -43,7 +49,7 @@ impl Default for Codec {
 }

 impl fmt::Debug for Codec {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "h1::Codec({:?})", self.flags)
    }
 }
@ -170,6 +176,7 @@ impl Encoder for Codec {
                };

                // encode message
+                let len = dst.len();
                self.encoder.encode(
                    dst,
                    &mut res,
@ -195,11 +202,17 @@ impl Encoder for Codec {

 #[cfg(test)]
 mod tests {
-    use bytes::BytesMut;
-    use http::Method;
+    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() {
--- a/actix-http/src/h1/decoder.rs
+++ b/actix-http/src/h1/decoder.rs
@ -1,13 +1,13 @@
-use std::convert::TryFrom;
 use std::io;
 use std::marker::PhantomData;
 use std::mem::MaybeUninit;
-use std::task::Poll;

 use actix_codec::Decoder;
-use bytes::{Buf, Bytes, BytesMut};
+use bytes::{Bytes, BytesMut};
+use futures::{Async, Poll};
 use http::header::{HeaderName, HeaderValue};
-use http::{header, Method, StatusCode, Uri, Version};
+use http::{header, HttpTryFrom, Method, StatusCode, Uri, Version};
+use httparse;
 use log::{debug, error, trace};

 use crate::error::ParseError;
@ -18,7 +18,7 @@ use crate::request::Request;
 const MAX_BUFFER_SIZE: usize = 131_072;
 const MAX_HEADERS: usize = 96;

-/// Incoming message decoder
+/// Incoming messagd decoder
 pub(crate) struct MessageDecoder<T: MessageType>(PhantomData<T>);

 #[derive(Debug)]
@ -79,8 +79,8 @@ pub(crate) trait MessageType: Sized {

                // Unsafe: httparse check header value for valid utf-8
                let value = unsafe {
-                    HeaderValue::from_maybe_shared_unchecked(
-                        slice.slice(idx.value.0..idx.value.1),
+                    HeaderValue::from_shared_unchecked(
+                        slice.slice(idx.value.0, idx.value.1),
                    )
                };
                match name {
@ -184,7 +184,6 @@ impl MessageType for Request {
        &mut self.head_mut().headers
    }

-    #[allow(clippy::uninit_assumed_init)]
    fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, ParseError> {
        // Unsafe: we read only this data only after httparse parses headers into.
        // performance bump for pipeline benchmarks.
@ -192,7 +191,7 @@ impl MessageType for Request {
            unsafe { MaybeUninit::uninit().assume_init() };

        let (len, method, uri, ver, h_len) = {
-            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] =
+            let mut parsed: [httparse::Header; MAX_HEADERS] =
                unsafe { MaybeUninit::uninit().assume_init() };

            let mut req = httparse::Request::new(&mut parsed);
@ -260,7 +259,6 @@ impl MessageType for ResponseHead {
        &mut self.headers
    }

-    #[allow(clippy::uninit_assumed_init)]
    fn decode(src: &mut BytesMut) -> Result<Option<(Self, PayloadType)>, ParseError> {
        // Unsafe: we read only this data only after httparse parses headers into.
        // performance bump for pipeline benchmarks.
@ -268,7 +266,7 @@ impl MessageType for ResponseHead {
            unsafe { MaybeUninit::uninit().assume_init() };

        let (len, ver, status, h_len) = {
-            let mut parsed: [httparse::Header<'_>; MAX_HEADERS] =
+            let mut parsed: [httparse::Header; MAX_HEADERS] =
                unsafe { MaybeUninit::uninit().assume_init() };

            let mut res = httparse::Response::new(&mut parsed);
@ -327,7 +325,7 @@ pub(crate) struct HeaderIndex {
 impl HeaderIndex {
    pub(crate) fn record(
        bytes: &[u8],
-        headers: &[httparse::Header<'_>],
+        headers: &[httparse::Header],
        indices: &mut [HeaderIndex],
    ) {
        let bytes_ptr = bytes.as_ptr() as usize;
@ -430,7 +428,7 @@ impl Decoder for PayloadDecoder {
                    let len = src.len() as u64;
                    let buf;
                    if *remaining > len {
-                        buf = src.split().freeze();
+                        buf = src.take().freeze();
                        *remaining -= len;
                    } else {
                        buf = src.split_to(*remaining as usize).freeze();
@ -444,10 +442,9 @@ impl Decoder for PayloadDecoder {
                loop {
                    let mut buf = None;
                    // advances the chunked state
-                    *state = match state.step(src, size, &mut buf) {
-                        Poll::Pending => return Ok(None),
-                        Poll::Ready(Ok(state)) => state,
-                        Poll::Ready(Err(e)) => return Err(e),
+                    *state = match state.step(src, size, &mut buf)? {
+                        Async::NotReady => return Ok(None),
+                        Async::Ready(state) => state,
                    };
                    if *state == ChunkedState::End {
                        trace!("End of chunked stream");
@ -465,7 +462,7 @@ impl Decoder for PayloadDecoder {
                if src.is_empty() {
                    Ok(None)
                } else {
-                    Ok(Some(PayloadItem::Chunk(src.split().freeze())))
+                    Ok(Some(PayloadItem::Chunk(src.take().freeze())))
                }
            }
        }
@ -476,10 +473,10 @@ macro_rules! byte (
    ($rdr:ident) => ({
        if $rdr.len() > 0 {
            let b = $rdr[0];
-            $rdr.advance(1);
+            $rdr.split_to(1);
            b
        } else {
-            return Poll::Pending
+            return Ok(Async::NotReady)
        }
    })
 );
@ -490,7 +487,7 @@ impl ChunkedState {
        body: &mut BytesMut,
        size: &mut u64,
        buf: &mut Option<Bytes>,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
+    ) -> Poll<ChunkedState, io::Error> {
        use self::ChunkedState::*;
        match *self {
            Size => ChunkedState::read_size(body, size),
@ -502,14 +499,10 @@ impl ChunkedState {
            BodyLf => ChunkedState::read_body_lf(body),
            EndCr => ChunkedState::read_end_cr(body),
            EndLf => ChunkedState::read_end_lf(body),
-            End => Poll::Ready(Ok(ChunkedState::End)),
+            End => Ok(Async::Ready(ChunkedState::End)),
        }
    }
-
-    fn read_size(
-        rdr: &mut BytesMut,
-        size: &mut u64,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
+    fn read_size(rdr: &mut BytesMut, size: &mut u64) -> Poll<ChunkedState, io::Error> {
        let radix = 16;
        match byte!(rdr) {
            b @ b'0'..=b'9' => {
@ -524,49 +517,48 @@ impl ChunkedState {
                *size *= radix;
                *size += u64::from(b + 10 - b'A');
            }
-            b'\t' | b' ' => return Poll::Ready(Ok(ChunkedState::SizeLws)),
-            b';' => return Poll::Ready(Ok(ChunkedState::Extension)),
-            b'\r' => return Poll::Ready(Ok(ChunkedState::SizeLf)),
+            b'\t' | b' ' => return Ok(Async::Ready(ChunkedState::SizeLws)),
+            b';' => return Ok(Async::Ready(ChunkedState::Extension)),
+            b'\r' => return Ok(Async::Ready(ChunkedState::SizeLf)),
            _ => {
-                return Poll::Ready(Err(io::Error::new(
+                return Err(io::Error::new(
                    io::ErrorKind::InvalidInput,
                    "Invalid chunk size line: Invalid Size",
-                )));
+                ));
            }
        }
-        Poll::Ready(Ok(ChunkedState::Size))
+        Ok(Async::Ready(ChunkedState::Size))
    }
-
-    fn read_size_lws(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+    fn read_size_lws(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
        trace!("read_size_lws");
        match byte!(rdr) {
            // LWS can follow the chunk size, but no more digits can come
-            b'\t' | b' ' => Poll::Ready(Ok(ChunkedState::SizeLws)),
-            b';' => Poll::Ready(Ok(ChunkedState::Extension)),
-            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
-            _ => Poll::Ready(Err(io::Error::new(
+            b'\t' | b' ' => Ok(Async::Ready(ChunkedState::SizeLws)),
+            b';' => Ok(Async::Ready(ChunkedState::Extension)),
+            b'\r' => Ok(Async::Ready(ChunkedState::SizeLf)),
+            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "Invalid chunk size linear white space",
-            ))),
+            )),
        }
    }
-    fn read_extension(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+    fn read_extension(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::SizeLf)),
-            _ => Poll::Ready(Ok(ChunkedState::Extension)), // no supported extensions
+            b'\r' => Ok(Async::Ready(ChunkedState::SizeLf)),
+            _ => Ok(Async::Ready(ChunkedState::Extension)), // no supported extensions
        }
    }
    fn read_size_lf(
        rdr: &mut BytesMut,
        size: &mut u64,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
+    ) -> Poll<ChunkedState, io::Error> {
        match byte!(rdr) {
-            b'\n' if *size > 0 => Poll::Ready(Ok(ChunkedState::Body)),
-            b'\n' if *size == 0 => Poll::Ready(Ok(ChunkedState::EndCr)),
-            _ => Poll::Ready(Err(io::Error::new(
+            b'\n' if *size > 0 => Ok(Async::Ready(ChunkedState::Body)),
+            b'\n' if *size == 0 => Ok(Async::Ready(ChunkedState::EndCr)),
+            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "Invalid chunk size LF",
-            ))),
+            )),
        }
    }

@ -574,16 +566,16 @@ impl ChunkedState {
        rdr: &mut BytesMut,
        rem: &mut u64,
        buf: &mut Option<Bytes>,
-    ) -> Poll<Result<ChunkedState, io::Error>> {
+    ) -> Poll<ChunkedState, io::Error> {
        trace!("Chunked read, remaining={:?}", rem);

        let len = rdr.len() as u64;
        if len == 0 {
-            Poll::Ready(Ok(ChunkedState::Body))
+            Ok(Async::Ready(ChunkedState::Body))
        } else {
            let slice;
            if *rem > len {
-                slice = rdr.split().freeze();
+                slice = rdr.take().freeze();
                *rem -= len;
            } else {
                slice = rdr.split_to(*rem as usize).freeze();
@ -591,47 +583,47 @@ impl ChunkedState {
            }
            *buf = Some(slice);
            if *rem > 0 {
-                Poll::Ready(Ok(ChunkedState::Body))
+                Ok(Async::Ready(ChunkedState::Body))
            } else {
-                Poll::Ready(Ok(ChunkedState::BodyCr))
+                Ok(Async::Ready(ChunkedState::BodyCr))
            }
        }
    }

-    fn read_body_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+    fn read_body_cr(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::BodyLf)),
-            _ => Poll::Ready(Err(io::Error::new(
+            b'\r' => Ok(Async::Ready(ChunkedState::BodyLf)),
+            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "Invalid chunk body CR",
-            ))),
+            )),
        }
    }
-    fn read_body_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+    fn read_body_lf(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
        match byte!(rdr) {
-            b'\n' => Poll::Ready(Ok(ChunkedState::Size)),
-            _ => Poll::Ready(Err(io::Error::new(
+            b'\n' => Ok(Async::Ready(ChunkedState::Size)),
+            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "Invalid chunk body LF",
-            ))),
+            )),
        }
    }
-    fn read_end_cr(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+    fn read_end_cr(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
        match byte!(rdr) {
-            b'\r' => Poll::Ready(Ok(ChunkedState::EndLf)),
-            _ => Poll::Ready(Err(io::Error::new(
+            b'\r' => Ok(Async::Ready(ChunkedState::EndLf)),
+            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "Invalid chunk end CR",
-            ))),
+            )),
        }
    }
-    fn read_end_lf(rdr: &mut BytesMut) -> Poll<Result<ChunkedState, io::Error>> {
+    fn read_end_lf(rdr: &mut BytesMut) -> Poll<ChunkedState, io::Error> {
        match byte!(rdr) {
-            b'\n' => Poll::Ready(Ok(ChunkedState::End)),
-            _ => Poll::Ready(Err(io::Error::new(
+            b'\n' => Ok(Async::Ready(ChunkedState::End)),
+            _ => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                "Invalid chunk end LF",
-            ))),
+            )),
        }
    }
 }
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@ -1,18 +1,23 @@
+#![allow(unused_imports, unused_variables, dead_code)]
+use std::fmt::Write as FmtWrite;
 use std::io::Write;
 use std::marker::PhantomData;
-use std::ptr::copy_nonoverlapping;
-use std::slice::from_raw_parts_mut;
-use std::{cmp, io};
+use std::rc::Rc;
+use std::str::FromStr;
+use std::{cmp, fmt, io, mem};

-use bytes::{BufMut, BytesMut};
+use bytes::{BufMut, Bytes, BytesMut};

 use crate::body::BodySize;
 use crate::config::ServiceConfig;
-use crate::header::map;
+use crate::header::{map, ContentEncoding};
 use crate::helpers;
-use crate::http::header::{CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use crate::http::{HeaderMap, StatusCode, Version};
-use crate::message::{ConnectionType, RequestHeadType};
+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;
@ -95,6 +100,14 @@ pub(crate) trait MessageType: Sized {
                }
            }
            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"),
        }

@ -131,8 +144,8 @@ pub(crate) trait MessageType: Sized {
        // write headers
        let mut pos = 0;
        let mut has_date = false;
-        let mut remaining = dst.capacity() - dst.len();
-        let mut buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
+        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,
@ -146,67 +159,61 @@ pub(crate) trait MessageType: Sized {
            match value {
                map::Value::One(ref val) => {
                    let v = val.as_ref();
-                    let v_len = v.len();
-                    let k_len = k.len();
-                    let len = k_len + v_len + 4;
+                    let len = k.len() + v.len() + 4;
                    if len > remaining {
                        unsafe {
                            dst.advance_mut(pos);
                        }
                        pos = 0;
                        dst.reserve(len * 2);
-                        remaining = dst.capacity() - dst.len();
-                        buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
+                        remaining = dst.remaining_mut();
+                        unsafe {
+                            buf = &mut *(dst.bytes_mut() as *mut _);
+                        }
                    }
                    // use upper Camel-Case
-                    unsafe {
-                        if camel_case {
-                            write_camel_case(k, from_raw_parts_mut(buf, k_len))
-                        } else {
-                            write_data(k, buf, k_len)
-                        }
-                        buf = buf.add(k_len);
-                        write_data(b": ", buf, 2);
-                        buf = buf.add(2);
-                        write_data(v, buf, v_len);
-                        buf = buf.add(v_len);
-                        write_data(b"\r\n", buf, 2);
-                        buf = buf.add(2);
-                        pos += len;
-                        remaining -= len;
+                    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 v_len = v.len();
-                        let k_len = k.len();
-                        let len = k_len + v_len + 4;
+                        let len = k.len() + v.len() + 4;
                        if len > remaining {
                            unsafe {
                                dst.advance_mut(pos);
                            }
                            pos = 0;
                            dst.reserve(len * 2);
-                            remaining = dst.capacity() - dst.len();
-                            buf = dst.bytes_mut().as_mut_ptr() as *mut u8;
+                            remaining = dst.remaining_mut();
+                            unsafe {
+                                buf = &mut *(dst.bytes_mut() as *mut _);
+                            }
                        }
                        // use upper Camel-Case
-                        unsafe {
-                            if camel_case {
-                                write_camel_case(k, from_raw_parts_mut(buf, k_len));
-                            } else {
-                                write_data(k, buf, k_len);
-                            }
-                            buf = buf.add(k_len);
-                            write_data(b": ", buf, 2);
-                            buf = buf.add(2);
-                            write_data(v, buf, v_len);
-                            buf = buf.add(v_len);
-                            write_data(b"\r\n", buf, 2);
-                            buf = buf.add(2);
-                        };
-                        pos += len;
+                        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;
                    }
                }
@ -291,12 +298,6 @@ impl MessageType for RequestHeadType {
                Version::HTTP_10 => "HTTP/1.0",
                Version::HTTP_11 => "HTTP/1.1",
                Version::HTTP_2 => "HTTP/2.0",
-                Version::HTTP_3 => "HTTP/3.0",
-                _ =>
-                    return Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "unsupported version"
-                    )),
            }
        )
        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
@ -329,7 +330,8 @@ impl<T: MessageType> MessageEncoder<T> {
        if !head {
            self.te = match length {
                BodySize::Empty => TransferEncoding::empty(),
-                BodySize::Sized(len) => TransferEncoding::length(len),
+                BodySize::Sized(len) => TransferEncoding::length(len as u64),
+                BodySize::Sized64(len) => TransferEncoding::length(len),
                BodySize::Stream => {
                    if message.chunked() && !stream {
                        TransferEncoding::chunked()
@ -477,10 +479,6 @@ impl<'a> io::Write for Writer<'a> {
    }
 }

-unsafe fn write_data(value: &[u8], buf: *mut u8, len: usize) {
-    copy_nonoverlapping(value.as_ptr(), buf, len);
-}
-
 fn write_camel_case(value: &[u8], buffer: &mut [u8]) {
    let mut index = 0;
    let key = value;
@ -511,14 +509,12 @@ fn write_camel_case(value: &[u8], buffer: &mut [u8]) {

 #[cfg(test)]
 mod tests {
-    use std::rc::Rc;
-
    use bytes::Bytes;
-    use http::header::AUTHORIZATION;
+    //use std::rc::Rc;

    use super::*;
    use crate::http::header::{HeaderValue, CONTENT_TYPE};
-    use crate::RequestHead;
+    use http::header::AUTHORIZATION;

    #[test]
    fn test_chunked_te() {
@ -529,7 +525,7 @@ mod tests {
            assert!(enc.encode(b"", &mut bytes).ok().unwrap());
        }
        assert_eq!(
-            bytes.split().freeze(),
+            bytes.take().freeze(),
            Bytes::from_static(b"4\r\ntest\r\n0\r\n\r\n")
        );
    }
@ -552,8 +548,7 @@ mod tests {
            ConnectionType::Close,
            &ServiceConfig::default(),
        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        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"));
@ -566,12 +561,23 @@ mod tests {
            ConnectionType::KeepAlive,
            &ServiceConfig::default(),
        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        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"));
@ -588,8 +594,7 @@ mod tests {
            ConnectionType::KeepAlive,
            &ServiceConfig::default(),
        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        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"));
@ -622,8 +627,7 @@ mod tests {
            ConnectionType::Close,
            &ServiceConfig::default(),
        );
-        let data =
-            String::from_utf8(Vec::from(bytes.split().freeze().as_ref())).unwrap();
+        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"));
--- a/actix-http/src/h1/expect.rs
+++ b/actix-http/src/h1/expect.rs
@ -1,23 +1,23 @@
-use std::task::{Context, Poll};
-
-use actix_service::{Service, ServiceFactory};
-use futures_util::future::{ok, Ready};
+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 ServiceFactory for ExpectHandler {
-    type Config = ();
+impl NewService for ExpectHandler {
+    type Config = ServerConfig;
    type Request = Request;
    type Response = Request;
    type Error = Error;
    type Service = ExpectHandler;
    type InitError = Error;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: ()) -> Self::Future {
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
        ok(ExpectHandler)
    }
 }
@ -26,10 +26,10 @@ impl Service for ExpectHandler {
    type Request = Request;
    type Response = Request;
    type Error = Error;
-    type Future = Ready<Result<Self::Response, Self::Error>>;
+    type Future = FutureResult<Self::Response, Self::Error>;

-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
    }

    fn call(&mut self, req: Request) -> Self::Future {
--- a/actix-http/src/h1/payload.rs
+++ b/actix-http/src/h1/payload.rs
@ -1,13 +1,12 @@
 //! Payload stream
 use std::cell::RefCell;
 use std::collections::VecDeque;
-use std::pin::Pin;
 use std::rc::{Rc, Weak};
-use std::task::{Context, Poll};

-use actix_utils::task::LocalWaker;
 use bytes::Bytes;
-use futures_core::Stream;
+use futures::task::current as current_task;
+use futures::task::Task;
+use futures::{Async, Poll, Stream};

 use crate::error::PayloadError;

@ -78,24 +77,15 @@ impl Payload {
    pub fn unread_data(&mut self, data: Bytes) {
        self.inner.borrow_mut().unread_data(data);
    }
-
-    #[inline]
-    pub fn readany(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
-    }
 }

 impl Stream for Payload {
-    type Item = Result<Bytes, PayloadError>;
+    type Item = Bytes;
+    type Error = PayloadError;

-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
-        self.inner.borrow_mut().readany(cx)
+    #[inline]
+    fn poll(&mut self) -> Poll<Option<Bytes>, PayloadError> {
+        self.inner.borrow_mut().readany()
    }
 }

@ -127,14 +117,19 @@ impl PayloadSender {
    }

    #[inline]
-    pub fn need_read(&self, cx: &mut Context<'_>) -> PayloadStatus {
+    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 {
-                shared.borrow_mut().io_task.register(cx.waker());
+                #[cfg(not(test))]
+                {
+                    if shared.borrow_mut().io_task.is_none() {
+                        shared.borrow_mut().io_task = Some(current_task());
+                    }
+                }
                PayloadStatus::Pause
            }
        } else {
@ -150,8 +145,8 @@ struct Inner {
    err: Option<PayloadError>,
    need_read: bool,
    items: VecDeque<Bytes>,
-    task: LocalWaker,
-    io_task: LocalWaker,
+    task: Option<Task>,
+    io_task: Option<Task>,
 }

 impl Inner {
@ -162,8 +157,8 @@ impl Inner {
            err: None,
            items: VecDeque::new(),
            need_read: true,
-            task: LocalWaker::new(),
-            io_task: LocalWaker::new(),
+            task: None,
+            io_task: None,
        }
    }

@ -183,7 +178,7 @@ impl Inner {
        self.items.push_back(data);
        self.need_read = self.len < MAX_BUFFER_SIZE;
        if let Some(task) = self.task.take() {
-            task.wake()
+            task.notify()
        }
    }

@ -192,28 +187,34 @@ impl Inner {
        self.len
    }

-    fn readany(
-        &mut self,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, PayloadError>>> {
+    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.eof {
-                self.task.register(cx.waker());
+            if self.need_read && self.task.is_none() && !self.eof {
+                self.task = Some(current_task());
            }
-            self.io_task.wake();
-            Poll::Ready(Some(Ok(data)))
+            if let Some(task) = self.io_task.take() {
+                task.notify()
+            }
+            Ok(Async::Ready(Some(data)))
        } else if let Some(err) = self.err.take() {
-            Poll::Ready(Some(Err(err)))
+            Err(err)
        } else if self.eof {
-            Poll::Ready(None)
+            Ok(Async::Ready(None))
        } else {
            self.need_read = true;
-            self.task.register(cx.waker());
-            self.io_task.wake();
-            Poll::Pending
+            #[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)
        }
    }

@ -226,19 +227,28 @@ impl Inner {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use futures_util::future::poll_fn;
+    use actix_rt::Runtime;
+    use futures::future::{lazy, result};

-    #[actix_rt::test]
-    async fn test_unread_data() {
-        let (_, mut payload) = Payload::create(false);
+    #[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);
+                payload.unread_data(Bytes::from("data"));
+                assert!(!payload.is_empty());
+                assert_eq!(payload.len(), 4);

-        assert_eq!(
-            Bytes::from("data"),
-            poll_fn(|cx| payload.readany(cx)).await.unwrap().unwrap()
-        );
+                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,19 +1,16 @@
-use std::future::Future;
+use std::fmt;
 use std::marker::PhantomData;
-use std::pin::Pin;
 use std::rc::Rc;
-use std::task::{Context, Poll};
-use std::{fmt, net};

-use actix_codec::{AsyncRead, AsyncWrite, Framed};
-use actix_rt::net::TcpStream;
-use actix_service::{pipeline_factory, IntoServiceFactory, Service, ServiceFactory};
-use futures_core::ready;
-use futures_util::future::{ok, Ready};
+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::ServiceConfig;
+use crate::config::{KeepAlive, ServiceConfig};
 use crate::error::{DispatchError, Error, ParseError};
 use crate::helpers::DataFactory;
 use crate::request::Request;
@ -23,32 +20,43 @@ use super::codec::Codec;
 use super::dispatcher::Dispatcher;
 use super::{ExpectHandler, Message, UpgradeHandler};

-/// `ServiceFactory` implementation for HTTP1 transport
-pub struct H1Service<T, S, B, X = ExpectHandler, U = UpgradeHandler<T>> {
+/// `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, B)>,
+    _t: PhantomData<(T, P, B)>,
 }

-impl<T, S, B> H1Service<T, S, B>
+impl<T, P, S, B> H1Service<T, P, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
+    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 config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
+    /// 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_factory(),
+            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,
@ -57,153 +65,17 @@ where
    }
 }

-impl<S, B, X, U> H1Service<TcpStream, S, B, X, U>
+impl<T, P, S, B, X, U> H1Service<T, P, S, B, X, U>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error>,
-    S::InitError: fmt::Debug,
-    S::Response: Into<Response<B>>,
-    B: MessageBody,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-    X::Error: Into<Error>,
-    X::InitError: fmt::Debug,
-    U: ServiceFactory<
-        Config = (),
-        Request = (Request, Framed<TcpStream, Codec>),
-        Response = (),
-    >,
-    U::Error: fmt::Display + Into<Error>,
-    U::InitError: fmt::Debug,
-{
-    /// Create simple tcp stream service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        Config = (),
-        Request = TcpStream,
-        Response = (),
-        Error = DispatchError,
-        InitError = (),
-    > {
-        pipeline_factory(|io: TcpStream| {
-            let peer_addr = io.peer_addr().ok();
-            ok((io, peer_addr))
-        })
-        .and_then(self)
-    }
-}
-
-#[cfg(feature = "openssl")]
-mod openssl {
-    use super::*;
-
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::HandshakeError, SslError};
-
-    impl<S, B, X, U> H1Service<SslStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        B: MessageBody,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        U: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<SslStream<TcpStream>, Codec>),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create openssl based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = SslError<HandshakeError<TcpStream>, DispatchError>,
-            InitError = (),
-        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(SslError::Ssl)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: SslStream<TcpStream>| {
-                let peer_addr = io.get_ref().peer_addr().ok();
-                ok((io, peer_addr))
-            })
-            .and_then(self.map_err(SslError::Service))
-        }
-    }
-}
-
-#[cfg(feature = "rustls")]
-mod rustls {
-    use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::SslError;
-    use std::{fmt, io};
-
-    impl<S, B, X, U> H1Service<TlsStream<TcpStream>, S, B, X, U>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error>,
-        S::InitError: fmt::Debug,
-        S::Response: Into<Response<B>>,
-        B: MessageBody,
-        X: ServiceFactory<Config = (), Request = Request, Response = Request>,
-        X::Error: Into<Error>,
-        X::InitError: fmt::Debug,
-        U: ServiceFactory<
-            Config = (),
-            Request = (Request, Framed<TlsStream<TcpStream>, Codec>),
-            Response = (),
-        >,
-        U::Error: fmt::Display + Into<Error>,
-        U::InitError: fmt::Debug,
-    {
-        /// Create rustls based service
-        pub fn rustls(
-            self,
-            config: ServerConfig,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = SslError<io::Error, DispatchError>,
-            InitError = (),
-        > {
-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(SslError::Ssl)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(|io: TlsStream<TcpStream>| {
-                let peer_addr = io.get_ref().0.peer_addr().ok();
-                ok((io, peer_addr))
-            })
-            .and_then(self.map_err(SslError::Service))
-        }
-    }
-}
-
-impl<T, S, B, X, U> H1Service<T, S, B, X, U>
-where
-    S: ServiceFactory<Config = (), Request = Request>,
+    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, S, B, X1, U>
+    pub fn expect<X1>(self, expect: X1) -> H1Service<T, P, S, B, X1, U>
    where
-        X1: ServiceFactory<Request = Request, Response = Request>,
+        X1: NewService<Request = Request, Response = Request>,
        X1::Error: Into<Error>,
        X1::InitError: fmt::Debug,
    {
@ -217,9 +89,9 @@ where
        }
    }

-    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, S, B, X, U1>
+    pub fn upgrade<U1>(self, upgrade: Option<U1>) -> H1Service<T, P, S, B, X, U1>
    where
-        U1: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+        U1: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
        U1::Error: fmt::Display,
        U1::InitError: fmt::Debug,
    {
@ -243,34 +115,38 @@ where
    }
 }

-impl<T, S, B, X, U> ServiceFactory for H1Service<T, S, B, X, U>
+impl<T, P, S, B, X, U> NewService for H1Service<T, P, S, B, X, U>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
+    T: IoStream,
+    S: NewService<Config = SrvConfig, Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    S::InitError: fmt::Debug,
    B: MessageBody,
-    X: ServiceFactory<Config = (), Request = Request, Response = Request>,
+    X: NewService<Config = SrvConfig, Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: fmt::Debug,
-    U: ServiceFactory<Config = (), Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
+    U: NewService<
+        Config = SrvConfig,
+        Request = (Request, Framed<T, Codec>),
+        Response = (),
+    >,
+    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
 {
-    type Config = ();
-    type Request = (T, Option<net::SocketAddr>);
+    type Config = SrvConfig;
+    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
    type InitError = ();
-    type Service = H1ServiceHandler<T, S::Service, B, X::Service, U::Service>;
-    type Future = H1ServiceResponse<T, S, B, X, U>;
+    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, _: ()) -> Self::Future {
+    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
        H1ServiceResponse {
-            fut: self.srv.new_service(()),
-            fut_ex: Some(self.expect.new_service(())),
-            fut_upg: self.upgrade.as_ref().map(|f| f.new_service(())),
+            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(),
@ -281,99 +157,88 @@ where
 }

 #[doc(hidden)]
-#[pin_project::pin_project]
-pub struct H1ServiceResponse<T, S, B, X, U>
+pub struct H1ServiceResponse<T, P, S, B, X, U>
 where
-    S: ServiceFactory<Request = Request>,
+    S: NewService<Request = Request>,
    S::Error: Into<Error>,
    S::InitError: fmt::Debug,
-    X: ServiceFactory<Request = Request, Response = Request>,
+    X: NewService<Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: fmt::Debug,
-    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
 {
-    #[pin]
    fut: S::Future,
-    #[pin]
    fut_ex: Option<X::Future>,
-    #[pin]
    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, B)>,
+    _t: PhantomData<(T, P, B)>,
 }

-impl<T, S, B, X, U> Future for H1ServiceResponse<T, S, B, X, U>
+impl<T, P, S, B, X, U> Future for H1ServiceResponse<T, P, S, B, X, U>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Request = Request>,
+    T: IoStream,
+    S: NewService<Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
    S::InitError: fmt::Debug,
    B: MessageBody,
-    X: ServiceFactory<Request = Request, Response = Request>,
+    X: NewService<Request = Request, Response = Request>,
    X::Error: Into<Error>,
    X::InitError: fmt::Debug,
-    U: ServiceFactory<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U: NewService<Request = (Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
    U::InitError: fmt::Debug,
 {
-    type Output = Result<H1ServiceHandler<T, S::Service, B, X::Service, U::Service>, ()>;
+    type Item = H1ServiceHandler<T, P, S::Service, B, X::Service, U::Service>;
+    type Error = ();

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
-
-        if let Some(fut) = this.fut_ex.as_pin_mut() {
-            let expect = ready!(fut
-                .poll(cx)
-                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
-            this = self.as_mut().project();
-            *this.expect = Some(expect);
-            this.fut_ex.set(None);
+    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(fut) = this.fut_upg.as_pin_mut() {
-            let upgrade = ready!(fut
-                .poll(cx)
-                .map_err(|e| log::error!("Init http service error: {:?}", e)))?;
-            this = self.as_mut().project();
-            *this.upgrade = Some(upgrade);
-            this.fut_ex.set(None);
+        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 result = ready!(this
+        let service = try_ready!(self
            .fut
-            .poll(cx)
+            .poll()
            .map_err(|e| log::error!("Init http service error: {:?}", e)));
-
-        Poll::Ready(result.map(|service| {
-            let this = self.as_mut().project();
-            H1ServiceHandler::new(
-                this.cfg.take().unwrap(),
-                service,
-                this.expect.take().unwrap(),
-                this.upgrade.take(),
-                this.on_connect.clone(),
-            )
-        }))
+        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, S: Service, B, X: Service, U: Service> {
+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, B)>,
+    _t: PhantomData<(T, P, B)>,
 }

-impl<T, S, B, X, U> H1ServiceHandler<T, S, B, X, U>
+impl<T, P, S, B, X, U> H1ServiceHandler<T, P, S, B, X, U>
 where
    S: Service<Request = Request>,
    S::Error: Into<Error>,
@ -390,7 +255,7 @@ where
        expect: X,
        upgrade: Option<U>,
        on_connect: Option<Rc<dyn Fn(&T) -> Box<dyn DataFactory>>>,
-    ) -> H1ServiceHandler<T, S, B, X, U> {
+    ) -> H1ServiceHandler<T, P, S, B, X, U> {
        H1ServiceHandler {
            srv: CloneableService::new(srv),
            expect: CloneableService::new(expect),
@ -402,9 +267,9 @@ where
    }
 }

-impl<T, S, B, X, U> Service for H1ServiceHandler<T, S, B, X, U>
+impl<T, P, S, B, X, U> Service for H1ServiceHandler<T, P, S, B, X, U>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
    S: Service<Request = Request>,
    S::Error: Into<Error>,
    S::Response: Into<Response<B>>,
@ -412,17 +277,17 @@ where
    X: Service<Request = Request, Response = Request>,
    X::Error: Into<Error>,
    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
-    U::Error: fmt::Display + Into<Error>,
+    U::Error: fmt::Display,
 {
-    type Request = (T, Option<net::SocketAddr>);
+    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
    type Future = Dispatcher<T, S, B, X, U>;

-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
        let ready = self
            .expect
-            .poll_ready(cx)
+            .poll_ready()
            .map_err(|e| {
                let e = e.into();
                log::error!("Http service readiness error: {:?}", e);
@ -432,7 +297,7 @@ where

        let ready = self
            .srv
-            .poll_ready(cx)
+            .poll_ready()
            .map_err(|e| {
                let e = e.into();
                log::error!("Http service readiness error: {:?}", e);
@ -441,27 +306,16 @@ where
            .is_ready()
            && ready;

-        let ready = if let Some(ref mut upg) = self.upgrade {
-            upg.poll_ready(cx)
-                .map_err(|e| {
-                    let e = e.into();
-                    log::error!("Http service readiness error: {:?}", e);
-                    DispatchError::Service(e)
-                })?
-                .is_ready()
-                && ready
-        } else {
-            ready
-        };
-
        if ready {
-            Poll::Ready(Ok(()))
+            Ok(Async::Ready(()))
        } else {
-            Poll::Pending
+            Ok(Async::NotReady)
        }
    }

-    fn call(&mut self, (io, addr): Self::Request) -> Self::Future {
+    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 {
@ -475,21 +329,20 @@ where
            self.expect.clone(),
            self.upgrade.clone(),
            on_connect,
-            addr,
        )
    }
 }

-/// `ServiceFactory` implementation for `OneRequestService` service
+/// `NewService` implementation for `OneRequestService` service
 #[derive(Default)]
-pub struct OneRequest<T> {
+pub struct OneRequest<T, P> {
    config: ServiceConfig,
-    _t: PhantomData<T>,
+    _t: PhantomData<(T, P)>,
 }

-impl<T> OneRequest<T>
+impl<T, P> OneRequest<T, P>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
 {
    /// Create new `H1SimpleService` instance.
    pub fn new() -> Self {
@ -500,49 +353,52 @@ where
    }
 }

-impl<T> ServiceFactory for OneRequest<T>
+impl<T, P> NewService for OneRequest<T, P>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
 {
-    type Config = ();
-    type Request = T;
+    type Config = SrvConfig;
+    type Request = Io<T, P>;
    type Response = (Request, Framed<T, Codec>);
    type Error = ParseError;
    type InitError = ();
-    type Service = OneRequestService<T>;
-    type Future = Ready<Result<Self::Service, Self::InitError>>;
+    type Service = OneRequestService<T, P>;
+    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: ()) -> Self::Future {
+    fn new_service(&self, _: &SrvConfig) -> Self::Future {
        ok(OneRequestService {
-            _t: PhantomData,
            config: self.config.clone(),
+            _t: PhantomData,
        })
    }
 }

 /// `Service` implementation for HTTP1 transport. Reads one request and returns
 /// request and framed object.
-pub struct OneRequestService<T> {
-    _t: PhantomData<T>,
+pub struct OneRequestService<T, P> {
    config: ServiceConfig,
+    _t: PhantomData<(T, P)>,
 }

-impl<T> Service for OneRequestService<T>
+impl<T, P> Service for OneRequestService<T, P>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
 {
-    type Request = T;
+    type Request = Io<T, P>;
    type Response = (Request, Framed<T, Codec>);
    type Error = ParseError;
    type Future = OneRequestServiceResponse<T>;

-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+    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, Codec::new(self.config.clone()))),
+            framed: Some(Framed::new(
+                req.into_parts().0,
+                Codec::new(self.config.clone()),
+            )),
        }
    }
 }
@ -550,28 +406,28 @@ where
 #[doc(hidden)]
 pub struct OneRequestServiceResponse<T>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
 {
    framed: Option<Framed<T, Codec>>,
 }

 impl<T> Future for OneRequestServiceResponse<T>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
 {
-    type Output = Result<(Request, Framed<T, Codec>), ParseError>;
+    type Item = (Request, Framed<T, Codec>);
+    type Error = ParseError;

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match self.framed.as_mut().unwrap().next_item(cx) {
-            Poll::Ready(Some(Ok(req))) => match req {
+    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) => {
-                    Poll::Ready(Ok((req, self.framed.take().unwrap())))
+                    Ok(Async::Ready((req, self.framed.take().unwrap())))
                }
                Message::Chunk(_) => unreachable!("Something is wrong"),
            },
-            Poll::Ready(Some(Err(err))) => Poll::Ready(Err(err)),
-            Poll::Ready(None) => Poll::Ready(Err(ParseError::Incomplete)),
-            Poll::Pending => Poll::Pending,
+            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,9 +1,10 @@
 use std::marker::PhantomData;
-use std::task::{Context, Poll};

 use actix_codec::Framed;
-use actix_service::{Service, ServiceFactory};
-use futures_util::future::Ready;
+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;
@ -11,16 +12,16 @@ use crate::request::Request;

 pub struct UpgradeHandler<T>(PhantomData<T>);

-impl<T> ServiceFactory for UpgradeHandler<T> {
-    type Config = ();
+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 = Ready<Result<Self::Service, Self::InitError>>;
+    type Future = FutureResult<Self::Service, Self::InitError>;

-    fn new_service(&self, _: ()) -> Self::Future {
+    fn new_service(&self, _: &ServerConfig) -> Self::Future {
        unimplemented!()
    }
 }
@ -29,10 +30,10 @@ impl<T> Service for UpgradeHandler<T> {
    type Request = (Request, Framed<T, Codec>);
    type Response = ();
    type Error = Error;
-    type Future = Ready<Result<Self::Response, Self::Error>>;
+    type Future = FutureResult<Self::Response, Self::Error>;

-    fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(Ok(()))
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        Ok(Async::Ready(()))
    }

    fn call(&mut self, _: Self::Request) -> Self::Future {
--- a/actix-http/src/h1/utils.rs
+++ b/actix-http/src/h1/utils.rs
@ -1,8 +1,5 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
 use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use futures::{Async, Future, Poll, Sink};

 use crate::body::{BodySize, MessageBody, ResponseBody};
 use crate::error::Error;
@ -10,10 +7,8 @@ use crate::h1::{Codec, Message};
 use crate::response::Response;

 /// Send http/1 response
-#[pin_project::pin_project]
 pub struct SendResponse<T, B> {
    res: Option<Message<(Response<()>, BodySize)>>,
-    #[pin]
    body: Option<ResponseBody<B>>,
    framed: Option<Framed<T, Codec>>,
 }
@ -36,66 +31,62 @@ where
 impl<T, B> Future for SendResponse<T, B>
 where
    T: AsyncRead + AsyncWrite,
-    B: MessageBody + Unpin,
+    B: MessageBody,
 {
-    type Output = Result<Framed<T, Codec>, Error>;
+    type Item = Framed<T, Codec>;
+    type Error = Error;

-    // TODO: rethink if we need loops in polls
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.project();
-
-        let mut body_done = this.body.is_none();
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        loop {
-            let mut body_ready = !body_done;
-            let framed = this.framed.as_mut().unwrap();
+            let mut body_ready = self.body.is_some();
+            let framed = self.framed.as_mut().unwrap();

            // send body
-            if this.res.is_none() && body_ready {
-                while body_ready && !body_done && !framed.is_write_buf_full() {
-                    match this.body.as_mut().as_pin_mut().unwrap().poll_next(cx)? {
-                        Poll::Ready(item) => {
-                            // body is done when item is None
-                            body_done = item.is_none();
-                            if body_done {
-                                let _ = this.body.take();
+            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.write(Message::Chunk(item))?;
+                            framed.force_send(Message::Chunk(item))?;
                        }
-                        Poll::Pending => body_ready = false,
+                        Async::NotReady => body_ready = false,
                    }
                }
            }

            // flush write buffer
            if !framed.is_write_buf_empty() {
-                match framed.flush(cx)? {
-                    Poll::Ready(_) => {
+                match framed.poll_complete()? {
+                    Async::Ready(_) => {
                        if body_ready {
                            continue;
                        } else {
-                            return Poll::Pending;
+                            return Ok(Async::NotReady);
                        }
                    }
-                    Poll::Pending => return Poll::Pending,
+                    Async::NotReady => return Ok(Async::NotReady),
                }
            }

            // send response
-            if let Some(res) = this.res.take() {
-                framed.write(res)?;
+            if let Some(res) = self.res.take() {
+                framed.force_send(res)?;
                continue;
            }

-            if !body_done {
+            if self.body.is_some() {
                if body_ready {
                    continue;
                } else {
-                    return Poll::Pending;
+                    return Ok(Async::NotReady);
                }
            } else {
                break;
            }
        }
-        Poll::Ready(Ok(this.framed.take().unwrap()))
+        Ok(Async::Ready(self.framed.take().unwrap()))
    }
 }
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@ -1,23 +1,27 @@
-use std::convert::TryFrom;
-use std::future::Future;
+use std::collections::VecDeque;
 use std::marker::PhantomData;
-use std::net;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::time::Instant;
+use std::{fmt, mem, net};

 use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::time::{Delay, Instant};
+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::SendStream;
-use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use log::{error, trace};
+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::{BodySize, MessageBody, ResponseBody};
+use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::cloneable::CloneableService;
 use crate::config::ServiceConfig;
-use crate::error::{DispatchError, Error};
+use crate::error::{DispatchError, Error, ParseError, PayloadError, ResponseError};
 use crate::helpers::DataFactory;
 use crate::httpmessage::HttpMessage;
 use crate::message::ResponseHead;
@ -28,11 +32,7 @@ use crate::response::Response;
 const CHUNK_SIZE: usize = 16_384;

 /// Dispatcher for HTTP/2 protocol
-#[pin_project::pin_project]
-pub struct Dispatcher<T, S: Service<Request = Request>, B: MessageBody>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-{
+pub struct Dispatcher<T: IoStream, S: Service<Request = Request>, B: MessageBody> {
    service: CloneableService<S>,
    connection: Connection<T, Bytes>,
    on_connect: Option<Box<dyn DataFactory>>,
@ -45,12 +45,12 @@ where

 impl<T, S, B> Dispatcher<T, S, B>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
    S: Service<Request = Request>,
    S::Error: Into<Error>,
-    // S::Future: 'static,
+    S::Future: 'static,
    S::Response: Into<Response<B>>,
-    B: MessageBody,
+    B: MessageBody + 'static,
 {
    pub(crate) fn new(
        service: CloneableService<S>,
@ -91,92 +91,76 @@ where

 impl<T, S, B> Future for Dispatcher<T, S, B>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Error>,
    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
+    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
-    type Output = Result<(), DispatchError>;
+    type Item = ();
+    type Error = DispatchError;

    #[inline]
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.get_mut();
-
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        loop {
-            match Pin::new(&mut this.connection).poll_accept(cx) {
-                Poll::Ready(None) => return Poll::Ready(Ok(())),
-                Poll::Ready(Some(Err(err))) => return Poll::Ready(Err(err.into())),
-                Poll::Ready(Some(Ok((req, res)))) => {
+            match self.connection.poll()? {
+                Async::Ready(None) => return Ok(Async::Ready(())),
+                Async::Ready(Some((req, res))) => {
                    // update keep-alive expire
-                    if this.ka_timer.is_some() {
-                        if let Some(expire) = this.config.keep_alive_expire() {
-                            this.ka_expire = 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(Payload::<
-                        crate::payload::PayloadStream,
-                    >::H2(
-                        crate::h2::Payload::new(body)
-                    ));
+                    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 = this.peer_addr;
+                    head.peer_addr = self.peer_addr;

                    // set on_connect data
-                    if let Some(ref on_connect) = this.on_connect {
+                    if let Some(ref on_connect) = self.on_connect {
                        on_connect.set(&mut req.extensions_mut());
                    }

-                    actix_rt::spawn(ServiceResponse::<
-                        S::Future,
-                        S::Response,
-                        S::Error,
-                        B,
-                    > {
+                    tokio_current_thread::spawn(ServiceResponse::<S::Future, B> {
                        state: ServiceResponseState::ServiceCall(
-                            this.service.call(req),
+                            self.service.call(req),
                            Some(res),
                        ),
-                        config: this.config.clone(),
+                        config: self.config.clone(),
                        buffer: None,
-                        _t: PhantomData,
-                    });
+                    })
                }
-                Poll::Pending => return Poll::Pending,
+                Async::NotReady => return Ok(Async::NotReady),
            }
        }
    }
 }

-#[pin_project::pin_project]
-struct ServiceResponse<F, I, E, B> {
-    #[pin]
+struct ServiceResponse<F, B> {
    state: ServiceResponseState<F, B>,
    config: ServiceConfig,
    buffer: Option<Bytes>,
-    _t: PhantomData<(I, E)>,
 }

-#[pin_project::pin_project]
 enum ServiceResponseState<F, B> {
-    ServiceCall(#[pin] F, Option<SendResponse<Bytes>>),
-    SendPayload(SendStream<Bytes>, #[pin] ResponseBody<B>),
+    ServiceCall(F, Option<SendResponse<Bytes>>),
+    SendPayload(SendStream<Bytes>, ResponseBody<B>),
 }

-impl<F, I, E, B> ServiceResponse<F, I, E, B>
+impl<F, B> ServiceResponse<F, B>
 where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
+    F: Future,
+    F::Error: Into<Error>,
+    F::Item: Into<Response<B>>,
+    B: MessageBody + 'static,
 {
    fn prepare_response(
        &self,
@ -210,6 +194,10 @@ where
                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
@ -227,128 +215,117 @@ where
        if !has_date {
            let mut bytes = BytesMut::with_capacity(29);
            self.config.set_date_header(&mut bytes);
-            res.headers_mut().insert(DATE, unsafe {
-                HeaderValue::from_maybe_shared_unchecked(bytes.freeze())
-            });
+            res.headers_mut()
+                .insert(DATE, HeaderValue::try_from(bytes.freeze()).unwrap());
        }

        res
    }
 }

-impl<F, I, E, B> Future for ServiceResponse<F, I, E, B>
+impl<F, B> Future for ServiceResponse<F, B>
 where
-    F: Future<Output = Result<I, E>>,
-    E: Into<Error>,
-    I: Into<Response<B>>,
-    B: MessageBody,
+    F: Future,
+    F::Error: Into<Error>,
+    F::Item: Into<Response<B>>,
+    B: MessageBody + 'static,
 {
-    type Output = ();
+    type Item = ();
+    type Error = ();

-    #[pin_project::project]
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let mut this = self.as_mut().project();
+    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(());

-        #[project]
-        match this.state.project() {
-            ServiceResponseState::ServiceCall(call, send) => match call.poll(cx) {
-                Poll::Ready(Ok(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 mut send = send.take().unwrap();
-                    let mut size = body.size();
-                    let h2_res = self.as_mut().prepare_response(res.head(), &mut size);
-                    this = self.as_mut().project();
+                        let stream =
+                            send.send_response(h2_res, size.is_eof()).map_err(|e| {
+                                trace!("Error sending h2 response: {:?}", e);
+                            })?;

-                    let stream = match send.send_response(h2_res, size.is_eof()) {
-                        Err(e) => {
-                            trace!("Error sending h2 response: {:?}", e);
-                            return Poll::Ready(());
+                        if size.is_eof() {
+                            Ok(Async::Ready(()))
+                        } else {
+                            self.state = ServiceResponseState::SendPayload(stream, body);
+                            self.poll()
                        }
-                        Ok(stream) => stream,
-                    };
+                    }
+                    Ok(Async::NotReady) => Ok(Async::NotReady),
+                    Err(e) => {
+                        let res: Response = e.into().into();
+                        let (res, body) = res.replace_body(());

-                    if size.is_eof() {
-                        Poll::Ready(())
-                    } else {
-                        this.state
-                            .set(ServiceResponseState::SendPayload(stream, body));
-                        self.poll(cx)
+                        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()
+                        }
                    }
                }
-                Poll::Pending => Poll::Pending,
-                Poll::Ready(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.as_mut().prepare_response(res.head(), &mut size);
-                    this = self.as_mut().project();
-
-                    let stream = match send.send_response(h2_res, size.is_eof()) {
-                        Err(e) => {
-                            trace!("Error sending h2 response: {:?}", e);
-                            return Poll::Ready(());
-                        }
-                        Ok(stream) => stream,
-                    };
-
-                    if size.is_eof() {
-                        Poll::Ready(())
-                    } else {
-                        this.state.set(ServiceResponseState::SendPayload(
-                            stream,
-                            body.into_body(),
-                        ));
-                        self.poll(cx)
-                    }
-                }
-            },
+            }
            ServiceResponseState::SendPayload(ref mut stream, ref mut body) => loop {
                loop {
-                    if let Some(ref mut buffer) = this.buffer {
-                        match stream.poll_capacity(cx) {
-                            Poll::Pending => return Poll::Pending,
-                            Poll::Ready(None) => return Poll::Ready(()),
-                            Poll::Ready(Some(Ok(cap))) => {
+                    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 Poll::Ready(());
+                                    return Err(());
                                } else if !buffer.is_empty() {
                                    let cap = std::cmp::min(buffer.len(), CHUNK_SIZE);
                                    stream.reserve_capacity(cap);
                                } else {
-                                    this.buffer.take();
+                                    self.buffer.take();
                                }
                            }
-                            Poll::Ready(Some(Err(e))) => {
-                                warn!("{:?}", e);
-                                return Poll::Ready(());
-                            }
                        }
                    } else {
-                        match body.as_mut().poll_next(cx) {
-                            Poll::Pending => return Poll::Pending,
-                            Poll::Ready(None) => {
+                        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(()));
                                }
-                                return Poll::Ready(());
                            }
-                            Poll::Ready(Some(Ok(chunk))) => {
+                            Ok(Async::Ready(Some(chunk))) => {
                                stream.reserve_capacity(std::cmp::min(
                                    chunk.len(),
                                    CHUNK_SIZE,
                                ));
-                                *this.buffer = Some(chunk);
+                                self.buffer = Some(chunk);
                            }
-                            Poll::Ready(Some(Err(e))) => {
+                            Err(e) => {
                                error!("Response payload stream error: {:?}", e);
-                                return Poll::Ready(());
+                                return Err(());
                            }
                        }
                    }
--- a/actix-http/src/h2/mod.rs
+++ b/actix-http/src/h2/mod.rs
@ -1,9 +1,9 @@
-//! HTTP/2 implementation
-use std::pin::Pin;
-use std::task::{Context, Poll};
+#![allow(dead_code, unused_imports)]
+
+use std::fmt;

 use bytes::Bytes;
-use futures_core::Stream;
+use futures::{Async, Poll, Stream};
 use h2::RecvStream;

 mod dispatcher;
@ -25,26 +25,22 @@ impl Payload {
 }

 impl Stream for Payload {
-    type Item = Result<Bytes, PayloadError>;
+    type Item = Bytes;
+    type Error = PayloadError;

-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-
-        match Pin::new(&mut this.pl).poll_data(cx) {
-            Poll::Ready(Some(Ok(chunk))) => {
+    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) = this.pl.flow_control().release_capacity(len) {
-                    Poll::Ready(Some(Err(err.into())))
+                if let Err(err) = self.pl.release_capacity().release_capacity(len) {
+                    Err(err.into())
                } else {
-                    Poll::Ready(Some(Ok(chunk)))
+                    Ok(Async::Ready(Some(chunk)))
                }
            }
-            Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err.into()))),
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(None) => Poll::Ready(None),
+            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,56 +1,62 @@
-use std::future::Future;
+use std::fmt::Debug;
 use std::marker::PhantomData;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::{net, rc};
+use std::{io, net, rc};

-use actix_codec::{AsyncRead, AsyncWrite};
-use actix_rt::net::TcpStream;
-use actix_service::{
-    fn_factory, fn_service, pipeline_factory, IntoServiceFactory, Service,
-    ServiceFactory,
-};
+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_core::ready;
-use futures_util::future::ok;
-use h2::server::{self, Handshake};
+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::ServiceConfig;
-use crate::error::{DispatchError, Error};
+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;

-/// `ServiceFactory` implementation for HTTP2 transport
-pub struct H2Service<T, S, B> {
+/// `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, B)>,
+    _t: PhantomData<(T, P, B)>,
 }

-impl<T, S, B> H2Service<T, S, B>
+impl<T, P, S, B> H2Service<T, P, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
+    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 with config.
-    pub(crate) fn with_config<F: IntoServiceFactory<S>>(
-        cfg: ServiceConfig,
-        service: F,
-    ) -> Self {
+    /// 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_factory(),
+            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,
        }
    }
@ -65,142 +71,26 @@ where
    }
 }

-impl<S, B> H2Service<TcpStream, S, B>
+impl<T, P, S, B> NewService for H2Service<T, P, S, B>
 where
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
+    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,
 {
-    /// Create simple tcp based service
-    pub fn tcp(
-        self,
-    ) -> impl ServiceFactory<
-        Config = (),
-        Request = TcpStream,
-        Response = (),
-        Error = DispatchError,
-        InitError = S::InitError,
-    > {
-        pipeline_factory(fn_factory(|| async {
-            Ok::<_, S::InitError>(fn_service(|io: TcpStream| {
-                let peer_addr = io.peer_addr().ok();
-                ok::<_, DispatchError>((io, peer_addr))
-            }))
-        }))
-        .and_then(self)
-    }
-}
-
-#[cfg(feature = "openssl")]
-mod openssl {
-    use actix_service::{fn_factory, fn_service};
-    use actix_tls::openssl::{Acceptor, SslAcceptor, SslStream};
-    use actix_tls::{openssl::HandshakeError, SslError};
-
-    use super::*;
-
-    impl<S, B> H2Service<SslStream<TcpStream>, S, B>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error> + 'static,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-        B: MessageBody + 'static,
-    {
-        /// Create ssl based service
-        pub fn openssl(
-            self,
-            acceptor: SslAcceptor,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = SslError<HandshakeError<TcpStream>, DispatchError>,
-            InitError = S::InitError,
-        > {
-            pipeline_factory(
-                Acceptor::new(acceptor)
-                    .map_err(SslError::Ssl)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(fn_factory(|| {
-                ok::<_, S::InitError>(fn_service(|io: SslStream<TcpStream>| {
-                    let peer_addr = io.get_ref().peer_addr().ok();
-                    ok((io, peer_addr))
-                }))
-            }))
-            .and_then(self.map_err(SslError::Service))
-        }
-    }
-}
-
-#[cfg(feature = "rustls")]
-mod rustls {
-    use super::*;
-    use actix_tls::rustls::{Acceptor, ServerConfig, TlsStream};
-    use actix_tls::SslError;
-    use std::io;
-
-    impl<S, B> H2Service<TlsStream<TcpStream>, S, B>
-    where
-        S: ServiceFactory<Config = (), Request = Request>,
-        S::Error: Into<Error> + 'static,
-        S::Response: Into<Response<B>> + 'static,
-        <S::Service as Service>::Future: 'static,
-        B: MessageBody + 'static,
-    {
-        /// Create openssl based service
-        pub fn rustls(
-            self,
-            mut config: ServerConfig,
-        ) -> impl ServiceFactory<
-            Config = (),
-            Request = TcpStream,
-            Response = (),
-            Error = SslError<io::Error, DispatchError>,
-            InitError = S::InitError,
-        > {
-            let protos = vec!["h2".to_string().into()];
-            config.set_protocols(&protos);
-
-            pipeline_factory(
-                Acceptor::new(config)
-                    .map_err(SslError::Ssl)
-                    .map_init_err(|_| panic!()),
-            )
-            .and_then(fn_factory(|| {
-                ok::<_, S::InitError>(fn_service(|io: TlsStream<TcpStream>| {
-                    let peer_addr = io.get_ref().0.peer_addr().ok();
-                    ok((io, peer_addr))
-                }))
-            }))
-            .and_then(self.map_err(SslError::Service))
-        }
-    }
-}
-
-impl<T, S, B> ServiceFactory for H2Service<T, S, B>
-where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
-    <S::Service as Service>::Future: 'static,
-    B: MessageBody + 'static,
-{
-    type Config = ();
-    type Request = (T, Option<net::SocketAddr>);
+    type Config = SrvConfig;
+    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
    type InitError = S::InitError;
-    type Service = H2ServiceHandler<T, S::Service, B>;
-    type Future = H2ServiceResponse<T, S, B>;
+    type Service = H2ServiceHandler<T, P, S::Service, B>;
+    type Future = H2ServiceResponse<T, P, S, B>;

-    fn new_service(&self, _: ()) -> Self::Future {
+    fn new_service(&self, cfg: &SrvConfig) -> Self::Future {
        H2ServiceResponse {
-            fut: self.srv.new_service(()),
+            fut: self.srv.new_service(cfg).into_future(),
            cfg: Some(self.cfg.clone()),
            on_connect: self.on_connect.clone(),
            _t: PhantomData,
@ -209,61 +99,56 @@ where
 }

 #[doc(hidden)]
-#[pin_project::pin_project]
-pub struct H2ServiceResponse<T, S: ServiceFactory, B> {
-    #[pin]
-    fut: S::Future,
+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, B)>,
+    _t: PhantomData<(T, P, B)>,
 }

-impl<T, S, B> Future for H2ServiceResponse<T, S, B>
+impl<T, P, S, B> Future for H2ServiceResponse<T, P, S, B>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
-    S: ServiceFactory<Config = (), Request = Request>,
-    S::Error: Into<Error> + 'static,
-    S::Response: Into<Response<B>> + 'static,
+    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 Output = Result<H2ServiceHandler<T, S::Service, B>, S::InitError>;
+    type Item = H2ServiceHandler<T, P, S::Service, B>;
+    type Error = S::InitError;

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
-
-        Poll::Ready(ready!(this.fut.poll(cx)).map(|service| {
-            let this = self.as_mut().project();
-            H2ServiceHandler::new(
-                this.cfg.take().unwrap(),
-                this.on_connect.clone(),
-                service,
-            )
-        }))
+    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, S: Service, B> {
+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, B)>,
+    _t: PhantomData<(T, P, B)>,
 }

-impl<T, S, B> H2ServiceHandler<T, S, B>
+impl<T, P, S, B> H2ServiceHandler<T, P, S, B>
 where
    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Error>,
    S::Future: 'static,
-    S::Response: Into<Response<B>> + '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, S, B> {
+    ) -> H2ServiceHandler<T, P, S, B> {
        H2ServiceHandler {
            cfg,
            on_connect,
@ -273,29 +158,31 @@ where
    }
 }

-impl<T, S, B> Service for H2ServiceHandler<T, S, B>
+impl<T, P, S, B> Service for H2ServiceHandler<T, P, S, B>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Error>,
    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
+    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
-    type Request = (T, Option<net::SocketAddr>);
+    type Request = Io<T, P>;
    type Response = ();
    type Error = DispatchError;
    type Future = H2ServiceHandlerResponse<T, S, B>;

-    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
-        self.srv.poll_ready(cx).map_err(|e| {
+    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, (io, addr): Self::Request) -> Self::Future {
+    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 {
@ -306,7 +193,7 @@ where
            state: State::Handshake(
                Some(self.srv.clone()),
                Some(self.cfg.clone()),
-                addr,
+                peer_addr,
                on_connect,
                server::handshake(io),
            ),
@ -314,9 +201,8 @@ where
    }
 }

-enum State<T, S: Service<Request = Request>, B: MessageBody>
+enum State<T: IoStream, S: Service<Request = Request>, B: MessageBody>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
    S::Future: 'static,
 {
    Incoming(Dispatcher<T, S, B>),
@ -331,11 +217,11 @@ where

 pub struct H2ServiceHandlerResponse<T, S, B>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Error>,
    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
+    S::Response: Into<Response<B>>,
    B: MessageBody + 'static,
 {
    state: State<T, S, B>,
@ -343,26 +229,27 @@ where

 impl<T, S, B> Future for H2ServiceHandlerResponse<T, S, B>
 where
-    T: AsyncRead + AsyncWrite + Unpin,
+    T: IoStream,
    S: Service<Request = Request>,
-    S::Error: Into<Error> + 'static,
+    S::Error: Into<Error>,
    S::Future: 'static,
-    S::Response: Into<Response<B>> + 'static,
+    S::Response: Into<Response<B>>,
    B: MessageBody,
 {
-    type Output = Result<(), DispatchError>;
+    type Item = ();
+    type Error = DispatchError;

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        match self.state {
-            State::Incoming(ref mut disp) => Pin::new(disp).poll(cx),
+            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 Pin::new(handshake).poll(cx) {
-                Poll::Ready(Ok(conn)) => {
+            ) => match handshake.poll() {
+                Ok(Async::Ready(conn)) => {
                    self.state = State::Incoming(Dispatcher::new(
                        srv.take().unwrap(),
                        conn,
@ -371,13 +258,13 @@ where
                        None,
                        *peer_addr,
                    ));
-                    self.poll(cx)
+                    self.poll()
                }
-                Poll::Ready(Err(err)) => {
+                Ok(Async::NotReady) => Ok(Async::NotReady),
+                Err(err) => {
                    trace!("H2 handshake error: {}", err);
-                    Poll::Ready(Err(err.into()))
+                    Err(err.into())
                }
-                Poll::Pending => Poll::Pending,
            },
        }
    }
--- a/actix-http/src/header/common/accept_charset.rs
+++ b/actix-http/src/header/common/accept_charset.rs
@ -63,7 +63,7 @@ header! {
    (AcceptCharset, ACCEPT_CHARSET) => (QualityItem<Charset>)+

    test_accept_charset {
-        // Test case from RFC
+        /// Test case from RFC
        test_header!(test1, vec![b"iso-8859-5, unicode-1-1;q=0.8"]);
    }
 }
--- a/actix-http/src/header/common/cache_control.rs
+++ b/actix-http/src/header/common/cache_control.rs
@ -74,18 +74,18 @@ impl Header for CacheControl {
 }

 impl fmt::Display for CacheControl {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt_comma_delimited(f, &self[..])
    }
 }

 impl IntoHeaderValue for CacheControl {
-    type Error = header::InvalidHeaderValue;
+    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_maybe_shared(writer.take())
+        header::HeaderValue::from_shared(writer.take())
    }
 }

@ -126,7 +126,7 @@ pub enum CacheDirective {
 }

 impl fmt::Display for CacheDirective {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use self::CacheDirective::*;
        fmt::Display::fmt(
            match *self {
--- a/actix-http/src/header/common/content_disposition.rs
+++ b/actix-http/src/header/common/content_disposition.rs
@ -90,40 +90,40 @@ pub enum DispositionParam {
    /// [RFC6266](https://tools.ietf.org/html/rfc6266) as *token "=" value*. Recipients should
    /// ignore unrecognizable parameters.
    Unknown(String, String),
-    /// An unrecognized extended parameter as defined in
+    /// 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
-    /// trailing asterisk is not included. Recipients should ignore unrecognizable parameters.
+    /// trailling asterisk is not included. Recipients should ignore unrecognizable parameters.
    UnknownExt(String, ExtendedValue),
 }

 impl DispositionParam {
-    /// Returns `true` if the parameter is [`Name`](DispositionParam::Name).
+    /// 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 parameter is [`Filename`](DispositionParam::Filename).
+    /// 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 parameter is [`FilenameExt`](DispositionParam::FilenameExt).
+    /// 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 parameter is [`Unknown`](DispositionParam::Unknown) and the `name`
+    /// 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 parameter is [`UnknownExt`](DispositionParam::UnknownExt) and the
+    /// 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 {
@ -373,7 +373,7 @@ impl ContentDisposition {
                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_unnecessary_percent_decode.
+                    // See also comments in test_from_raw_uncessary_percent_decode.
                    DispositionParam::Filename(value)
                } else {
                    DispositionParam::Unknown(param_name.to_owned(), value)
@ -423,7 +423,7 @@ impl ContentDisposition {

    /// Return the value of *name* if exists.
    pub fn get_name(&self) -> Option<&str> {
-        self.parameters.iter().filter_map(|p| p.as_name()).next()
+        self.parameters.iter().filter_map(|p| p.as_name()).nth(0)
    }

    /// Return the value of *filename* if exists.
@ -431,7 +431,7 @@ impl ContentDisposition {
        self.parameters
            .iter()
            .filter_map(|p| p.as_filename())
-            .next()
+            .nth(0)
    }

    /// Return the value of *filename\** if exists.
@ -439,7 +439,7 @@ impl ContentDisposition {
        self.parameters
            .iter()
            .filter_map(|p| p.as_filename_ext())
-            .next()
+            .nth(0)
    }

    /// Return the value of the parameter which the `name` matches.
@ -448,7 +448,7 @@ impl ContentDisposition {
        self.parameters
            .iter()
            .filter_map(|p| p.as_unknown(name))
-            .next()
+            .nth(0)
    }

    /// Return the value of the extended parameter which the `name` matches.
@ -457,17 +457,17 @@ impl ContentDisposition {
        self.parameters
            .iter()
            .filter_map(|p| p.as_unknown_ext(name))
-            .next()
+            .nth(0)
    }
 }

 impl IntoHeaderValue for ContentDisposition {
-    type Error = header::InvalidHeaderValue;
+    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_maybe_shared(writer.take())
+        header::HeaderValue::from_shared(writer.take())
    }
 }

@ -486,7 +486,7 @@ impl Header for ContentDisposition {
 }

 impl fmt::Display for DispositionType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            DispositionType::Inline => write!(f, "inline"),
            DispositionType::Attachment => write!(f, "attachment"),
@ -497,7 +497,7 @@ impl fmt::Display for DispositionType {
 }

 impl fmt::Display for DispositionParam {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    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
@ -529,7 +529,7 @@ impl fmt::Display for DispositionParam {
        //               ; to use within parameter values
        //
        //
-        // See also comments in test_from_raw_unnecessary_percent_decode.
+        // See also comments in test_from_raw_uncessary_percent_decode.
        lazy_static! {
            static ref RE: Regex = Regex::new("[\x00-\x08\x10-\x1F\x7F\"\\\\]").unwrap();
        }
@ -555,7 +555,7 @@ impl fmt::Display for DispositionParam {
 }

 impl fmt::Display for ContentDisposition {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.disposition)?;
        self.parameters
            .iter()
@ -676,7 +676,7 @@ mod tests {
    fn test_from_raw_unordered() {
        let a = HeaderValue::from_static(
            "form-data; dummy=3; filename=\"sample.png\" ; name=upload;",
-            // Actually, a trailing semicolon is not compliant. But it is fine to accept.
+            // Actually, a trailling semolocon is not compliant. But it is fine to accept.
        );
        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
        let b = ContentDisposition {
@ -768,8 +768,9 @@ mod tests {
        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 =
+            HeaderValue::from_str("form-data; name=upload; filename=\"文件.webp\"")
+                .unwrap();
        let a: ContentDisposition = ContentDisposition::from_raw(&a).unwrap();
        let b = ContentDisposition {
            disposition: DispositionType::FormData,
@ -833,7 +834,7 @@ mod tests {
    }

    #[test]
-    fn test_from_raw_unnecessary_percent_decode() {
+    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
@ -883,11 +884,7 @@ mod tests {
        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());
+        assert!(ContentDisposition::from_raw(&a).expect("parse cd").get_filename().expect("filename").is_empty());
    }

    #[test]
--- a/actix-http/src/header/common/content_range.rs
+++ b/actix-http/src/header/common/content_range.rs
@ -3,7 +3,7 @@ use std::str::FromStr;

 use crate::error::ParseError;
 use crate::header::{
-    HeaderValue, IntoHeaderValue, InvalidHeaderValue, Writer, CONTENT_RANGE,
+    HeaderValue, IntoHeaderValue, InvalidHeaderValueBytes, Writer, CONTENT_RANGE,
 };

 header! {
@ -166,7 +166,7 @@ impl FromStr for ContentRangeSpec {
 }

 impl Display for ContentRangeSpec {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ContentRangeSpec::Bytes {
                range,
@ -198,11 +198,11 @@ impl Display for ContentRangeSpec {
 }

 impl IntoHeaderValue for ContentRangeSpec {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    fn try_into(self) -> Result<HeaderValue, Self::Error> {
        let mut writer = Writer::new();
        let _ = write!(&mut writer, "{}", self);
-        HeaderValue::from_maybe_shared(writer.take())
+        HeaderValue::from_shared(writer.take())
    }
 }
--- a/actix-http/src/header/common/if_range.rs
+++ b/actix-http/src/header/common/if_range.rs
@ -3,7 +3,7 @@ use std::fmt::{self, Display, Write};
 use crate::error::ParseError;
 use crate::header::{
    self, from_one_raw_str, EntityTag, Header, HeaderName, HeaderValue, HttpDate,
-    IntoHeaderValue, InvalidHeaderValue, Writer,
+    IntoHeaderValue, InvalidHeaderValueBytes, Writer,
 };
 use crate::httpmessage::HttpMessage;

@ -87,7 +87,7 @@ impl Header for IfRange {
 }

 impl Display for IfRange {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            IfRange::EntityTag(ref x) => Display::fmt(x, f),
            IfRange::Date(ref x) => Display::fmt(x, f),
@ -96,12 +96,12 @@ impl Display for IfRange {
 }

 impl IntoHeaderValue for IfRange {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    fn try_into(self) -> Result<HeaderValue, Self::Error> {
        let mut writer = Writer::new();
        let _ = write!(&mut writer, "{}", self);
-        HeaderValue::from_maybe_shared(writer.take())
+        HeaderValue::from_shared(writer.take())
    }
 }

--- a/actix-http/src/header/common/mod.rs
+++ b/actix-http/src/header/common/mod.rs
@ -159,18 +159,18 @@ macro_rules! header {
        }
        impl std::fmt::Display for $id {
            #[inline]
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> ::std::fmt::Result {
                $crate::http::header::fmt_comma_delimited(f, &self.0[..])
            }
        }
        impl $crate::http::header::IntoHeaderValue for $id {
-            type Error = $crate::http::header::InvalidHeaderValue;
+            type Error = $crate::http::header::InvalidHeaderValueBytes;

            fn try_into(self) -> Result<$crate::http::header::HeaderValue, Self::Error> {
                use std::fmt::Write;
                let mut writer = $crate::http::header::Writer::new();
                let _ = write!(&mut writer, "{}", self);
-                $crate::http::header::HeaderValue::from_maybe_shared(writer.take())
+                $crate::http::header::HeaderValue::from_shared(writer.take())
            }
        }
    };
@ -195,18 +195,18 @@ macro_rules! header {
        }
        impl std::fmt::Display for $id {
            #[inline]
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                $crate::http::header::fmt_comma_delimited(f, &self.0[..])
            }
        }
        impl $crate::http::header::IntoHeaderValue for $id {
-            type Error = $crate::http::header::InvalidHeaderValue;
+            type Error = $crate::http::header::InvalidHeaderValueBytes;

            fn try_into(self) -> Result<$crate::http::header::HeaderValue, Self::Error> {
                use std::fmt::Write;
                let mut writer = $crate::http::header::Writer::new();
                let _ = write!(&mut writer, "{}", self);
-                $crate::http::header::HeaderValue::from_maybe_shared(writer.take())
+                $crate::http::header::HeaderValue::from_shared(writer.take())
            }
        }
    };
@ -231,12 +231,12 @@ macro_rules! header {
        }
        impl std::fmt::Display for $id {
            #[inline]
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                std::fmt::Display::fmt(&self.0, f)
            }
        }
        impl $crate::http::header::IntoHeaderValue for $id {
-            type Error = $crate::http::header::InvalidHeaderValue;
+            type Error = $crate::http::header::InvalidHeaderValueBytes;

            fn try_into(self) -> Result<$crate::http::header::HeaderValue, Self::Error> {
                self.0.try_into()
@ -276,7 +276,7 @@ macro_rules! header {
        }
        impl std::fmt::Display for $id {
            #[inline]
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                match *self {
                    $id::Any => f.write_str("*"),
                    $id::Items(ref fields) => $crate::http::header::fmt_comma_delimited(
@ -285,13 +285,13 @@ macro_rules! header {
            }
        }
        impl $crate::http::header::IntoHeaderValue for $id {
-            type Error = $crate::http::header::InvalidHeaderValue;
+            type Error = $crate::http::header::InvalidHeaderValueBytes;

            fn try_into(self) -> Result<$crate::http::header::HeaderValue, Self::Error> {
                use std::fmt::Write;
                let mut writer = $crate::http::header::Writer::new();
                let _ = write!(&mut writer, "{}", self);
-                $crate::http::header::HeaderValue::from_maybe_shared(writer.take())
+                $crate::http::header::HeaderValue::from_shared(writer.take())
            }
        }
    };
--- a/actix-http/src/header/common/range.rs
+++ b/actix-http/src/header/common/range.rs
@ -7,7 +7,7 @@ use header::{Header, Raw};
 /// `Range` header, defined in [RFC7233](https://tools.ietf.org/html/rfc7233#section-3.1)
 ///
 /// The "Range" header field on a GET request modifies the method
-/// semantics to request transfer of only one or more sub-ranges of the
+/// semantics to request transfer of only one or more subranges of the
 /// selected representation data, rather than the entire selected
 /// representation data.
 ///
@ -183,13 +183,13 @@ impl fmt::Display for Range {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Range::Bytes(ref ranges) => {
-                write!(f, "bytes=")?;
+                try!(write!(f, "bytes="));

                for (i, range) in ranges.iter().enumerate() {
                    if i != 0 {
-                        f.write_str(",")?;
+                        try!(f.write_str(","));
                    }
-                    Display::fmt(range, f)?;
+                    try!(Display::fmt(range, f));
                }
                Ok(())
            }
@ -214,9 +214,9 @@ impl FromStr for Range {
                }
                Ok(Range::Bytes(ranges))
            }
-            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => {
-                Ok(Range::Unregistered(unit.to_owned(), range_str.to_owned()))
-            }
+            (Some(unit), Some(range_str)) if unit != "" && range_str != "" => Ok(
+                Range::Unregistered(unit.to_owned(), range_str.to_owned()),
+            ),
            _ => Err(::Error::Header),
        }
    }
@ -229,8 +229,7 @@ impl FromStr for ByteRangeSpec {
        let mut parts = s.splitn(2, '-');

        match (parts.next(), parts.next()) {
-            (Some(""), Some(end)) => end
-                .parse()
+            (Some(""), Some(end)) => end.parse()
                .or(Err(::Error::Header))
                .map(ByteRangeSpec::Last),
            (Some(start), Some("")) => start
@ -273,138 +272,163 @@ impl Header for Range {
    }
 }

-#[cfg(test)]
-mod tests {
-    use super::*;
+#[test]
+fn test_parse_bytes_range_valid() {
+    let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
+    let r3 = Range::bytes(1, 100);
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);

-    #[test]
-    fn test_parse_bytes_range_valid() {
-        let r: Range = Header::parse_header(&"bytes=1-100".into()).unwrap();
-        let r2: Range = Header::parse_header(&"bytes=1-100,-".into()).unwrap();
-        let r3 = Range::bytes(1, 100);
-        assert_eq!(r, r2);
-        assert_eq!(r2, r3);
+    let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
+    let r2: Range =
+        Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
+    let r3 = Range::Bytes(vec![
+        ByteRangeSpec::FromTo(1, 100),
+        ByteRangeSpec::AllFrom(200),
+    ]);
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);

-        let r: Range = Header::parse_header(&"bytes=1-100,200-".into()).unwrap();
-        let r2: Range =
-            Header::parse_header(&"bytes= 1-100 , 101-xxx,  200- ".into()).unwrap();
-        let r3 = Range::Bytes(vec![
-            ByteRangeSpec::FromTo(1, 100),
-            ByteRangeSpec::AllFrom(200),
-        ]);
-        assert_eq!(r, r2);
-        assert_eq!(r2, r3);
+    let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
+    let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
+    let r3 = Range::Bytes(vec![
+        ByteRangeSpec::FromTo(1, 100),
+        ByteRangeSpec::Last(100),
+    ]);
+    assert_eq!(r, r2);
+    assert_eq!(r2, r3);

-        let r: Range = Header::parse_header(&"bytes=1-100,-100".into()).unwrap();
-        let r2: Range = Header::parse_header(&"bytes=1-100, ,,-100".into()).unwrap();
-        let r3 = Range::Bytes(vec![
-            ByteRangeSpec::FromTo(1, 100),
-            ByteRangeSpec::Last(100),
-        ]);
-        assert_eq!(r, r2);
-        assert_eq!(r2, r3);
-
-        let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
-        let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
-        assert_eq!(r, r2);
-    }
-
-    #[test]
-    fn test_parse_unregistered_range_valid() {
-        let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
-        let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
-        assert_eq!(r, r2);
-
-        let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
-        let r2 = Range::Unregistered("custom".to_owned(), "abcd".to_owned());
-        assert_eq!(r, r2);
-
-        let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
-        let r2 = Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
-        assert_eq!(r, r2);
-    }
-
-    #[test]
-    fn test_parse_invalid() {
-        let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
-        assert_eq!(r.ok(), None);
-
-        let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
-        assert_eq!(r.ok(), None);
-
-        let r: ::Result<Range> = Header::parse_header(&"abc".into());
-        assert_eq!(r.ok(), None);
-
-        let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
-        assert_eq!(r.ok(), None);
-
-        let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
-        assert_eq!(r.ok(), None);
-
-        let r: ::Result<Range> = Header::parse_header(&"custom=".into());
-        assert_eq!(r.ok(), None);
-
-        let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
-        assert_eq!(r.ok(), None);
-    }
-
-    #[test]
-    fn test_fmt() {
-        use header::Headers;
-
-        let mut headers = Headers::new();
-
-        headers.set(Range::Bytes(vec![
-            ByteRangeSpec::FromTo(0, 1000),
-            ByteRangeSpec::AllFrom(2000),
-        ]));
-        assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
-
-        headers.clear();
-        headers.set(Range::Bytes(vec![]));
-
-        assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
-
-        headers.clear();
-        headers.set(Range::Unregistered("custom".to_owned(), "1-xxx".to_owned()));
-
-        assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
-    }
-
-    #[test]
-    fn test_byte_range_spec_to_satisfiable_range() {
-        assert_eq!(
-            Some((0, 0)),
-            ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3)
-        );
-        assert_eq!(
-            Some((1, 2)),
-            ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3)
-        );
-        assert_eq!(
-            Some((1, 2)),
-            ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3)
-        );
-        assert_eq!(None, ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3));
-        assert_eq!(None, ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3));
-        assert_eq!(None, ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0));
-
-        assert_eq!(
-            Some((0, 2)),
-            ByteRangeSpec::AllFrom(0).to_satisfiable_range(3)
-        );
-        assert_eq!(
-            Some((2, 2)),
-            ByteRangeSpec::AllFrom(2).to_satisfiable_range(3)
-        );
-        assert_eq!(None, ByteRangeSpec::AllFrom(3).to_satisfiable_range(3));
-        assert_eq!(None, ByteRangeSpec::AllFrom(5).to_satisfiable_range(3));
-        assert_eq!(None, ByteRangeSpec::AllFrom(0).to_satisfiable_range(0));
-
-        assert_eq!(Some((1, 2)), ByteRangeSpec::Last(2).to_satisfiable_range(3));
-        assert_eq!(Some((2, 2)), ByteRangeSpec::Last(1).to_satisfiable_range(3));
-        assert_eq!(Some((0, 2)), ByteRangeSpec::Last(5).to_satisfiable_range(3));
-        assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
-        assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
-    }
+    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+    let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+    assert_eq!(r, r2);
+}
+
+#[test]
+fn test_parse_unregistered_range_valid() {
+    let r: Range = Header::parse_header(&"custom=1-100,-100".into()).unwrap();
+    let r2 = Range::Unregistered("custom".to_owned(), "1-100,-100".to_owned());
+    assert_eq!(r, r2);
+
+    let r: Range = Header::parse_header(&"custom=abcd".into()).unwrap();
+    let r2 = Range::Unregistered("custom".to_owned(), "abcd".to_owned());
+    assert_eq!(r, r2);
+
+    let r: Range = Header::parse_header(&"custom=xxx-yyy".into()).unwrap();
+    let r2 = Range::Unregistered("custom".to_owned(), "xxx-yyy".to_owned());
+    assert_eq!(r, r2);
+}
+
+#[test]
+fn test_parse_invalid() {
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-a,-".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-2-3".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"abc".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=1-100=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"bytes=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"custom=".into());
+    assert_eq!(r.ok(), None);
+
+    let r: ::Result<Range> = Header::parse_header(&"=1-100".into());
+    assert_eq!(r.ok(), None);
+}
+
+#[test]
+fn test_fmt() {
+    use header::Headers;
+
+    let mut headers = Headers::new();
+
+    headers.set(Range::Bytes(vec![
+        ByteRangeSpec::FromTo(0, 1000),
+        ByteRangeSpec::AllFrom(2000),
+    ]));
+    assert_eq!(&headers.to_string(), "Range: bytes=0-1000,2000-\r\n");
+
+    headers.clear();
+    headers.set(Range::Bytes(vec![]));
+
+    assert_eq!(&headers.to_string(), "Range: bytes=\r\n");
+
+    headers.clear();
+    headers.set(Range::Unregistered(
+        "custom".to_owned(),
+        "1-xxx".to_owned(),
+    ));
+
+    assert_eq!(&headers.to_string(), "Range: custom=1-xxx\r\n");
+}
+
+#[test]
+fn test_byte_range_spec_to_satisfiable_range() {
+    assert_eq!(
+        Some((0, 0)),
+        ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        Some((1, 2)),
+        ByteRangeSpec::FromTo(1, 2).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        Some((1, 2)),
+        ByteRangeSpec::FromTo(1, 5).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        None,
+        ByteRangeSpec::FromTo(3, 3).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        None,
+        ByteRangeSpec::FromTo(2, 1).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        None,
+        ByteRangeSpec::FromTo(0, 0).to_satisfiable_range(0)
+    );
+
+    assert_eq!(
+        Some((0, 2)),
+        ByteRangeSpec::AllFrom(0).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        Some((2, 2)),
+        ByteRangeSpec::AllFrom(2).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        None,
+        ByteRangeSpec::AllFrom(3).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        None,
+        ByteRangeSpec::AllFrom(5).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        None,
+        ByteRangeSpec::AllFrom(0).to_satisfiable_range(0)
+    );
+
+    assert_eq!(
+        Some((1, 2)),
+        ByteRangeSpec::Last(2).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        Some((2, 2)),
+        ByteRangeSpec::Last(1).to_satisfiable_range(3)
+    );
+    assert_eq!(
+        Some((0, 2)),
+        ByteRangeSpec::Last(5).to_satisfiable_range(3)
+    );
+    assert_eq!(None, ByteRangeSpec::Last(0).to_satisfiable_range(3));
+    assert_eq!(None, ByteRangeSpec::Last(2).to_satisfiable_range(0));
 }
--- a/actix-http/src/header/map.rs
+++ b/actix-http/src/header/map.rs
@ -1,18 +1,17 @@
-use std::collections::hash_map::{self, Entry};
-use std::convert::TryFrom;
-
 use either::Either;
-use fxhash::FxHashMap;
+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 multi-map of [`HeaderName`] to values.
+/// `HeaderMap` is an multimap of [`HeaderName`] to values.
 ///
 /// [`HeaderName`]: struct.HeaderName.html
 #[derive(Debug, Clone)]
 pub struct HeaderMap {
-    pub(crate) inner: FxHashMap<HeaderName, Value>,
+    pub(crate) inner: HashMap<HeaderName, Value>,
 }

 #[derive(Debug, Clone)]
@ -57,7 +56,7 @@ impl HeaderMap {
    /// allocate.
    pub fn new() -> Self {
        HeaderMap {
-            inner: FxHashMap::default(),
+            inner: HashMap::new(),
        }
    }

@ -71,7 +70,7 @@ impl HeaderMap {
    /// More capacity than requested may be allocated.
    pub fn with_capacity(capacity: usize) -> HeaderMap {
        HeaderMap {
-            inner: FxHashMap::with_capacity_and_hasher(capacity, Default::default()),
+            inner: HashMap::with_capacity(capacity),
        }
    }

@ -143,7 +142,7 @@ impl HeaderMap {
    /// 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<'_> {
+    pub fn get_all<N: AsName>(&self, name: N) -> GetAll {
        GetAll {
            idx: 0,
            item: self.get2(name),
@ -187,7 +186,7 @@ impl HeaderMap {
    /// 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<'_> {
+    pub fn iter(&self) -> Iter {
        Iter::new(self.inner.iter())
    }

@ -196,7 +195,7 @@ impl HeaderMap {
    /// 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<'_> {
+    pub fn keys(&self) -> Keys {
        Keys(self.inner.keys())
    }

--- a/actix-http/src/header/mod.rs
+++ b/actix-http/src/header/mod.rs
@ -1,7 +1,6 @@
 //! Various http headers
 // This is mostly copy of [hyper](https://github.com/hyperium/hyper/tree/master/src/header)

-use std::convert::TryFrom;
 use std::{fmt, str::FromStr};

 use bytes::{Bytes, BytesMut};
@ -74,58 +73,58 @@ impl<'a> IntoHeaderValue for &'a [u8] {
 }

 impl IntoHeaderValue for Bytes {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    #[inline]
    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::from_maybe_shared(self)
+        HeaderValue::from_shared(self)
    }
 }

 impl IntoHeaderValue for Vec<u8> {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    #[inline]
    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self)
+        HeaderValue::from_shared(Bytes::from(self))
    }
 }

 impl IntoHeaderValue for String {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    #[inline]
    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(self)
+        HeaderValue::from_shared(Bytes::from(self))
    }
 }

 impl IntoHeaderValue for usize {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    #[inline]
    fn try_into(self) -> Result<HeaderValue, Self::Error> {
        let s = format!("{}", self);
-        HeaderValue::try_from(s)
+        HeaderValue::from_shared(Bytes::from(s))
    }
 }

 impl IntoHeaderValue for u64 {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    #[inline]
    fn try_into(self) -> Result<HeaderValue, Self::Error> {
        let s = format!("{}", self);
-        HeaderValue::try_from(s)
+        HeaderValue::from_shared(Bytes::from(s))
    }
 }

 impl IntoHeaderValue for Mime {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    #[inline]
    fn try_into(self) -> Result<HeaderValue, Self::Error> {
-        HeaderValue::try_from(format!("{}", self))
+        HeaderValue::from_shared(Bytes::from(format!("{}", self)))
    }
 }

@ -205,7 +204,7 @@ impl Writer {
        }
    }
    fn take(&mut self) -> Bytes {
-        self.buf.split().freeze()
+        self.buf.take().freeze()
    }
 }

@ -217,7 +216,7 @@ impl fmt::Write for Writer {
    }

    #[inline]
-    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
+    fn write_fmt(&mut self, args: fmt::Arguments) -> fmt::Result {
        fmt::write(self, args)
    }
 }
@ -259,7 +258,7 @@ pub fn from_one_raw_str<T: FromStr>(val: Option<&HeaderValue>) -> Result<T, Pars
 #[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
+pub fn fmt_comma_delimited<T>(f: &mut fmt::Formatter, parts: &[T]) -> fmt::Result
 where
    T: fmt::Display,
 {
@ -361,7 +360,7 @@ pub fn parse_extended_value(
 }

 impl fmt::Display for ExtendedValue {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    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 {
@ -376,7 +375,7 @@ impl fmt::Display for ExtendedValue {
 /// [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 {
+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)
 }
--- a/actix-http/src/header/shared/charset.rs
+++ b/actix-http/src/header/shared/charset.rs
@ -98,7 +98,7 @@ impl Charset {
 }

 impl Display for Charset {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(self.label())
    }
 }
@ -137,22 +137,17 @@ impl FromStr for Charset {
    }
 }

-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse() {
-        assert_eq!(Us_Ascii, "us-ascii".parse().unwrap());
-        assert_eq!(Us_Ascii, "US-Ascii".parse().unwrap());
-        assert_eq!(Us_Ascii, "US-ASCII".parse().unwrap());
-        assert_eq!(Shift_Jis, "Shift-JIS".parse().unwrap());
-        assert_eq!(Ext("ABCD".to_owned()), "abcd".parse().unwrap());
-    }
-
-    #[test]
-    fn test_display() {
-        assert_eq!("US-ASCII", format!("{}", Us_Ascii));
-        assert_eq!("ABCD", format!("{}", Ext("ABCD".to_owned())));
-    }
+#[test]
+fn test_parse() {
+    assert_eq!(Us_Ascii, "us-ascii".parse().unwrap());
+    assert_eq!(Us_Ascii, "US-Ascii".parse().unwrap());
+    assert_eq!(Us_Ascii, "US-ASCII".parse().unwrap());
+    assert_eq!(Shift_Jis, "Shift-JIS".parse().unwrap());
+    assert_eq!(Ext("ABCD".to_owned()), "abcd".parse().unwrap());
+}
+
+#[test]
+fn test_display() {
+    assert_eq!("US-ASCII", format!("{}", Us_Ascii));
+    assert_eq!("ABCD", format!("{}", Ext("ABCD".to_owned())));
 }
--- a/actix-http/src/header/shared/encoding.rs
+++ b/actix-http/src/header/shared/encoding.rs
@ -27,7 +27,7 @@ pub enum Encoding {
 }

 impl fmt::Display for Encoding {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(match *self {
            Chunked => "chunked",
            Brotli => "br",
--- a/actix-http/src/header/shared/entity.rs
+++ b/actix-http/src/header/shared/entity.rs
@ -1,7 +1,7 @@
 use std::fmt::{self, Display, Write};
 use std::str::FromStr;

-use crate::header::{HeaderValue, IntoHeaderValue, InvalidHeaderValue, Writer};
+use crate::header::{HeaderValue, IntoHeaderValue, InvalidHeaderValueBytes, Writer};

 /// check that each char in the slice is either:
 /// 1. `%x21`, or
@ -113,7 +113,7 @@ impl EntityTag {
 }

 impl Display for EntityTag {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.weak {
            write!(f, "W/\"{}\"", self.tag)
        } else {
@ -157,12 +157,12 @@ impl FromStr for EntityTag {
 }

 impl IntoHeaderValue for EntityTag {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    fn try_into(self) -> Result<HeaderValue, Self::Error> {
        let mut wrt = Writer::new();
        write!(wrt, "{}", self).unwrap();
-        HeaderValue::from_maybe_shared(wrt.take())
+        HeaderValue::from_shared(wrt.take())
    }
 }

--- a/actix-http/src/header/shared/httpdate.rs
+++ b/actix-http/src/header/shared/httpdate.rs
@ -1,99 +1,117 @@
 use std::fmt::{self, Display};
 use std::io::Write;
 use std::str::FromStr;
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};

-use bytes::{buf::BufMutExt, BytesMut};
-use http::header::{HeaderValue, InvalidHeaderValue};
-use time::{offset, OffsetDateTime, PrimitiveDateTime};
+use bytes::{BufMut, BytesMut};
+use http::header::{HeaderValue, InvalidHeaderValueBytes};

 use crate::error::ParseError;
 use crate::header::IntoHeaderValue;
-use crate::time_parser;

 /// A timestamp with HTTP formatting and parsing
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct HttpDate(OffsetDateTime);
+pub struct HttpDate(time::Tm);

 impl FromStr for HttpDate {
    type Err = ParseError;

    fn from_str(s: &str) -> Result<HttpDate, ParseError> {
-        match time_parser::parse_http_date(s) {
-            Some(t) => Ok(HttpDate(t.assume_utc())),
-            None => Err(ParseError::Header),
+        match time::strptime(s, "%a, %d %b %Y %T %Z")
+            .or_else(|_| time::strptime(s, "%A, %d-%b-%y %T %Z"))
+            .or_else(|_| time::strptime(s, "%c"))
+        {
+            Ok(t) => Ok(HttpDate(t)),
+            Err(_) => Err(ParseError::Header),
        }
    }
 }

 impl Display for HttpDate {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.0.format("%a, %d %b %Y %H:%M:%S GMT"), f)
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.0.to_utc().rfc822(), f)
    }
 }

-impl From<OffsetDateTime> for HttpDate {
-    fn from(dt: OffsetDateTime) -> HttpDate {
-        HttpDate(dt)
+impl From<time::Tm> for HttpDate {
+    fn from(tm: time::Tm) -> HttpDate {
+        HttpDate(tm)
    }
 }

 impl From<SystemTime> for HttpDate {
    fn from(sys: SystemTime) -> HttpDate {
-        HttpDate(PrimitiveDateTime::from(sys).assume_utc())
+        let tmspec = match sys.duration_since(UNIX_EPOCH) {
+            Ok(dur) => {
+                time::Timespec::new(dur.as_secs() as i64, dur.subsec_nanos() as i32)
+            }
+            Err(err) => {
+                let neg = err.duration();
+                time::Timespec::new(
+                    -(neg.as_secs() as i64),
+                    -(neg.subsec_nanos() as i32),
+                )
+            }
+        };
+        HttpDate(time::at_utc(tmspec))
    }
 }

 impl IntoHeaderValue for HttpDate {
-    type Error = InvalidHeaderValue;
+    type Error = InvalidHeaderValueBytes;

    fn try_into(self) -> Result<HeaderValue, Self::Error> {
        let mut wrt = BytesMut::with_capacity(29).writer();
-        write!(
-            wrt,
-            "{}",
-            self.0
-                .to_offset(offset!(UTC))
-                .format("%a, %d %b %Y %H:%M:%S GMT")
-        )
-        .unwrap();
-        HeaderValue::from_maybe_shared(wrt.get_mut().split().freeze())
+        write!(wrt, "{}", self.0.rfc822()).unwrap();
+        HeaderValue::from_shared(wrt.get_mut().take().freeze())
    }
 }

 impl From<HttpDate> for SystemTime {
    fn from(date: HttpDate) -> SystemTime {
-        let dt = date.0;
-        let epoch = OffsetDateTime::unix_epoch();
-
-        UNIX_EPOCH + (dt - epoch)
+        let spec = date.0.to_timespec();
+        if spec.sec >= 0 {
+            UNIX_EPOCH + Duration::new(spec.sec as u64, spec.nsec as u32)
+        } else {
+            UNIX_EPOCH - Duration::new(spec.sec as u64, spec.nsec as u32)
+        }
    }
 }

 #[cfg(test)]
 mod tests {
    use super::HttpDate;
-    use time::{date, time, PrimitiveDateTime};
+    use time::Tm;
+
+    const NOV_07: HttpDate = HttpDate(Tm {
+        tm_nsec: 0,
+        tm_sec: 37,
+        tm_min: 48,
+        tm_hour: 8,
+        tm_mday: 7,
+        tm_mon: 10,
+        tm_year: 94,
+        tm_wday: 0,
+        tm_isdst: 0,
+        tm_yday: 0,
+        tm_utcoff: 0,
+    });

    #[test]
    fn test_date() {
-        let nov_07 = HttpDate(
-            PrimitiveDateTime::new(date!(1994 - 11 - 07), time!(8:48:37)).assume_utc(),
-        );
-
        assert_eq!(
            "Sun, 07 Nov 1994 08:48:37 GMT".parse::<HttpDate>().unwrap(),
-            nov_07
+            NOV_07
        );
        assert_eq!(
            "Sunday, 07-Nov-94 08:48:37 GMT"
                .parse::<HttpDate>()
                .unwrap(),
-            nov_07
+            NOV_07
        );
        assert_eq!(
            "Sun Nov  7 08:48:37 1994".parse::<HttpDate>().unwrap(),
-            nov_07
+            NOV_07
        );
        assert!("this-is-no-date".parse::<HttpDate>().is_err());
    }
--- a/actix-http/src/header/shared/quality_item.rs
+++ b/actix-http/src/header/shared/quality_item.rs
@ -53,7 +53,7 @@ impl<T: PartialEq> cmp::PartialOrd for QualityItem<T> {
 }

 impl<T: fmt::Display> fmt::Display for QualityItem<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.item, f)?;
        match self.quality.0 {
            1000 => Ok(()),
--- a/actix-http/src/helpers.rs
+++ b/actix-http/src/helpers.rs
@ -1,46 +1,173 @@
-use std::io;
+use std::{io, mem, ptr, slice};

 use bytes::{BufMut, BytesMut};
 use http::Version;

 use crate::extensions::Extensions;

-const DIGITS_START: u8 = b'0';
+const DEC_DIGITS_LUT: &[u8] = b"0001020304050607080910111213141516171819\
+      2021222324252627282930313233343536373839\
+      4041424344454647484950515253545556575859\
+      6061626364656667686970717273747576777879\
+      8081828384858687888990919293949596979899";

-pub(crate) fn write_status_line(version: Version, n: u16, bytes: &mut BytesMut) {
+pub(crate) const STATUS_LINE_BUF_SIZE: usize = 13;
+
+pub(crate) fn write_status_line(version: Version, mut n: u16, bytes: &mut BytesMut) {
+    let mut buf: [u8; STATUS_LINE_BUF_SIZE] = [
+        b'H', b'T', b'T', b'P', b'/', b'1', b'.', b'1', b' ', b' ', b' ', b' ', b' ',
+    ];
    match version {
-        Version::HTTP_11 => bytes.put_slice(b"HTTP/1.1 "),
-        Version::HTTP_10 => bytes.put_slice(b"HTTP/1.0 "),
-        Version::HTTP_09 => bytes.put_slice(b"HTTP/0.9 "),
-        _ => {
-            // other HTTP version handlers do not use this method
+        Version::HTTP_2 => buf[5] = b'2',
+        Version::HTTP_10 => buf[7] = b'0',
+        Version::HTTP_09 => {
+            buf[5] = b'0';
+            buf[7] = b'9';
+        }
+        _ => (),
+    }
+
+    let mut curr: isize = 12;
+    let buf_ptr = buf.as_mut_ptr();
+    let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+    let four = n > 999;
+
+    // decode 2 more chars, if > 2 chars
+    let d1 = (n % 100) << 1;
+    n /= 100;
+    curr -= 2;
+    unsafe {
+        ptr::copy_nonoverlapping(lut_ptr.offset(d1 as isize), buf_ptr.offset(curr), 2);
+    }
+
+    // decode last 1 or 2 chars
+    if n < 10 {
+        curr -= 1;
+        unsafe {
+            *buf_ptr.offset(curr) = (n as u8) + b'0';
+        }
+    } else {
+        let d1 = n << 1;
+        curr -= 2;
+        unsafe {
+            ptr::copy_nonoverlapping(
+                lut_ptr.offset(d1 as isize),
+                buf_ptr.offset(curr),
+                2,
+            );
        }
    }

-    let d100 = (n / 100) as u8;
-    let d10 = ((n / 10) % 10) as u8;
-    let d1 = (n % 10) as u8;
-
-    bytes.put_u8(DIGITS_START + d100);
-    bytes.put_u8(DIGITS_START + d10);
-    bytes.put_u8(DIGITS_START + d1);
-
-    // trailing space before reason
-    bytes.put_u8(b' ');
+    bytes.put_slice(&buf);
+    if four {
+        bytes.put(b' ');
+    }
 }

 /// NOTE: bytes object has to contain enough space
-pub fn write_content_length(n: u64, bytes: &mut BytesMut) {
-    if n == 0 {
-        bytes.put_slice(b"\r\ncontent-length: 0\r\n");
-        return;
+pub fn write_content_length(mut n: usize, bytes: &mut BytesMut) {
+    if n < 10 {
+        let mut buf: [u8; 21] = [
+            b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e',
+            b'n', b'g', b't', b'h', b':', b' ', b'0', b'\r', b'\n',
+        ];
+        buf[18] = (n as u8) + b'0';
+        bytes.put_slice(&buf);
+    } else if n < 100 {
+        let mut buf: [u8; 22] = [
+            b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e',
+            b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'\r', b'\n',
+        ];
+        let d1 = n << 1;
+        unsafe {
+            ptr::copy_nonoverlapping(
+                DEC_DIGITS_LUT.as_ptr().add(d1),
+                buf.as_mut_ptr().offset(18),
+                2,
+            );
+        }
+        bytes.put_slice(&buf);
+    } else if n < 1000 {
+        let mut buf: [u8; 23] = [
+            b'\r', b'\n', b'c', b'o', b'n', b't', b'e', b'n', b't', b'-', b'l', b'e',
+            b'n', b'g', b't', b'h', b':', b' ', b'0', b'0', b'0', b'\r', b'\n',
+        ];
+        // decode 2 more chars, if > 2 chars
+        let d1 = (n % 100) << 1;
+        n /= 100;
+        unsafe {
+            ptr::copy_nonoverlapping(
+                DEC_DIGITS_LUT.as_ptr().add(d1),
+                buf.as_mut_ptr().offset(19),
+                2,
+            )
+        };
+
+        // decode last 1
+        buf[18] = (n as u8) + b'0';
+
+        bytes.put_slice(&buf);
+    } else {
+        bytes.put_slice(b"\r\ncontent-length: ");
+        convert_usize(n, bytes);
+    }
+}
+
+pub(crate) fn convert_usize(mut n: usize, bytes: &mut BytesMut) {
+    let mut curr: isize = 39;
+    let mut buf: [u8; 41] = unsafe { mem::MaybeUninit::uninit().assume_init() };
+    buf[39] = b'\r';
+    buf[40] = b'\n';
+    let buf_ptr = buf.as_mut_ptr();
+    let lut_ptr = DEC_DIGITS_LUT.as_ptr();
+
+    // eagerly decode 4 characters at a time
+    while n >= 10_000 {
+        let rem = (n % 10_000) as isize;
+        n /= 10_000;
+
+        let d1 = (rem / 100) << 1;
+        let d2 = (rem % 100) << 1;
+        curr -= 4;
+        unsafe {
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+            ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
+        }
    }

-    let mut buf = itoa::Buffer::new();
+    // if we reach here numbers are <= 9999, so at most 4 chars long
+    let mut n = n as isize; // possibly reduce 64bit math

-    bytes.put_slice(b"\r\ncontent-length: ");
-    bytes.put_slice(buf.format(n).as_bytes());
-    bytes.put_slice(b"\r\n");
+    // decode 2 more chars, if > 2 chars
+    if n >= 100 {
+        let d1 = (n % 100) << 1;
+        n /= 100;
+        curr -= 2;
+        unsafe {
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+        }
+    }
+
+    // decode last 1 or 2 chars
+    if n < 10 {
+        curr -= 1;
+        unsafe {
+            *buf_ptr.offset(curr) = (n as u8) + b'0';
+        }
+    } else {
+        let d1 = n << 1;
+        curr -= 2;
+        unsafe {
+            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
+        }
+    }
+
+    unsafe {
+        bytes.extend_from_slice(slice::from_raw_parts(
+            buf_ptr.offset(curr),
+            41 - curr as usize,
+        ));
+    }
 }

 pub(crate) struct Writer<'a>(pub &'a mut BytesMut);
@ -69,103 +196,40 @@ impl<T: Clone + 'static> DataFactory for Data<T> {

 #[cfg(test)]
 mod tests {
-    use std::str::from_utf8;
-
    use super::*;

-    #[test]
-    fn test_status_line() {
-        let mut bytes = BytesMut::new();
-        bytes.reserve(50);
-        write_status_line(Version::HTTP_11, 200, &mut bytes);
-        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/1.1 200 ");
-
-        let mut bytes = BytesMut::new();
-        bytes.reserve(50);
-        write_status_line(Version::HTTP_09, 404, &mut bytes);
-        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/0.9 404 ");
-
-        let mut bytes = BytesMut::new();
-        bytes.reserve(50);
-        write_status_line(Version::HTTP_09, 515, &mut bytes);
-        assert_eq!(from_utf8(&bytes.split().freeze()).unwrap(), "HTTP/0.9 515 ");
-    }
-
    #[test]
    fn test_write_content_length() {
        let mut bytes = BytesMut::new();
        bytes.reserve(50);
        write_content_length(0, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 0\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 0\r\n"[..]);
        bytes.reserve(50);
        write_content_length(9, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 9\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 9\r\n"[..]);
        bytes.reserve(50);
        write_content_length(10, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 10\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 10\r\n"[..]);
        bytes.reserve(50);
        write_content_length(99, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 99\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 99\r\n"[..]);
        bytes.reserve(50);
        write_content_length(100, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 100\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 100\r\n"[..]);
        bytes.reserve(50);
        write_content_length(101, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 101\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 101\r\n"[..]);
        bytes.reserve(50);
        write_content_length(998, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 998\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 998\r\n"[..]);
        bytes.reserve(50);
        write_content_length(1000, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 1000\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 1000\r\n"[..]);
        bytes.reserve(50);
        write_content_length(1001, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 1001\r\n"[..]);
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 1001\r\n"[..]);
        bytes.reserve(50);
        write_content_length(5909, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 5909\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(9999, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 9999\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(10001, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 10001\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(59094, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 59094\r\n"[..]);
-        bytes.reserve(50);
-        write_content_length(99999, &mut bytes);
-        assert_eq!(bytes.split().freeze(), b"\r\ncontent-length: 99999\r\n"[..]);
-
-        bytes.reserve(50);
-        write_content_length(590947, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 590947\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(999999, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 999999\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(5909471, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 5909471\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(59094718, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 59094718\r\n"[..]
-        );
-        bytes.reserve(50);
-        write_content_length(4294973728, &mut bytes);
-        assert_eq!(
-            bytes.split().freeze(),
-            b"\r\ncontent-length: 4294973728\r\n"[..]
-        );
+        assert_eq!(bytes.take().freeze(), b"\r\ncontent-length: 5909\r\n"[..]);
    }
 }
--- a/actix-http/src/httpmessage.rs
+++ b/actix-http/src/httpmessage.rs
@ -25,10 +25,10 @@ pub trait HttpMessage: Sized {
    fn take_payload(&mut self) -> Payload<Self::Stream>;

    /// Request's extensions container
-    fn extensions(&self) -> Ref<'_, Extensions>;
+    fn extensions(&self) -> Ref<Extensions>;

    /// Mutable reference to a the request's extensions container
-    fn extensions_mut(&self) -> RefMut<'_, Extensions>;
+    fn extensions_mut(&self) -> RefMut<Extensions>;

    #[doc(hidden)]
    /// Get a header
@ -105,7 +105,7 @@ pub trait HttpMessage: Sized {

    /// Load request cookies.
    #[inline]
-    fn cookies(&self) -> Result<Ref<'_, Vec<Cookie<'static>>>, CookieParseError> {
+    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) {
@ -153,12 +153,12 @@ where
    }

    /// Request's extensions container
-    fn extensions(&self) -> Ref<'_, Extensions> {
+    fn extensions(&self) -> Ref<Extensions> {
        (**self).extensions()
    }

    /// Mutable reference to a the request's extensions container
-    fn extensions_mut(&self) -> RefMut<'_, Extensions> {
+    fn extensions_mut(&self) -> RefMut<Extensions> {
        (**self).extensions_mut()
    }
 }
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@ -1,24 +1,20 @@
 //! Basic http primitives for actix-net framework.
-#![warn(rust_2018_idioms, warnings)]
 #![allow(
    clippy::type_complexity,
    clippy::too_many_arguments,
    clippy::new_without_default,
-    clippy::borrow_interior_mutable_const
+    clippy::borrow_interior_mutable_const,
+    clippy::write_with_newline
 )]

 #[macro_use]
 extern crate log;

-#[macro_use]
-mod macros;
-
 pub mod body;
 mod builder;
 pub mod client;
 mod cloneable;
 mod config;
-#[cfg(feature = "compress")]
 pub mod encoding;
 mod extensions;
 mod header;
@ -30,7 +26,6 @@ mod payload;
 mod request;
 mod response;
 mod service;
-mod time_parser;

 pub mod cookie;
 pub mod error;
@ -56,7 +51,7 @@ pub mod http {
    // re-exports
    pub use http::header::{HeaderName, HeaderValue};
    pub use http::uri::PathAndQuery;
-    pub use http::{uri, Error, Uri};
+    pub use http::{uri, Error, HttpTryFrom, Uri};
    pub use http::{Method, StatusCode, Version};

    pub use crate::cookie::{Cookie, CookieBuilder};
@ -69,10 +64,3 @@ pub mod http {
    pub use crate::header::ContentEncoding;
    pub use crate::message::ConnectionType;
 }
-
-/// Http protocol
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub enum Protocol {
-    Http1,
-    Http2,
-}
--- a/actix-http/src/macros.rs
+++ b/actix-http/src/macros.rs
@ -1,95 +0,0 @@
-#[macro_export]
-macro_rules! downcast_get_type_id {
-    () => {
-        /// A helper method to get the type ID of the type
-        /// this trait is implemented on.
-        /// This method is unsafe to *implement*, since `downcast_ref` relies
-        /// on the returned `TypeId` to perform a cast.
-        ///
-        /// Unfortunately, Rust has no notion of a trait method that is
-        /// unsafe to implement (marking it as `unsafe` makes it unsafe
-        /// to *call*). As a workaround, we require this method
-        /// to return a private type along with the `TypeId`. This
-        /// private type (`PrivateHelper`) has a private constructor,
-        /// making it impossible for safe code to construct outside of
-        /// this module. This ensures that safe code cannot violate
-        /// type-safety by implementing this method.
-        #[doc(hidden)]
-        fn __private_get_type_id__(&self) -> (std::any::TypeId, PrivateHelper)
-        where
-            Self: 'static,
-        {
-            (std::any::TypeId::of::<Self>(), PrivateHelper(()))
-        }
-    };
-}
-
-//Generate implementation for dyn $name
-#[macro_export]
-macro_rules! downcast {
-    ($name:ident) => {
-        /// A struct with a private constructor, for use with
-        /// `__private_get_type_id__`. Its single field is private,
-        /// ensuring that it can only be constructed from this module
-        #[doc(hidden)]
-        pub struct PrivateHelper(());
-
-        impl dyn $name + 'static {
-            /// Downcasts generic body to a specific type.
-            pub fn downcast_ref<T: $name + 'static>(&self) -> Option<&T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
-                    // Safety: external crates cannot override the default
-                    // implementation of `__private_get_type_id__`, since
-                    // it requires returning a private type. We can therefore
-                    // rely on the returned `TypeId`, which ensures that this
-                    // case is correct.
-                    unsafe { Some(&*(self as *const dyn $name as *const T)) }
-                } else {
-                    None
-                }
-            }
-            /// Downcasts a generic body to a mutable specific type.
-            pub fn downcast_mut<T: $name + 'static>(&mut self) -> Option<&mut T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
-                    // Safety: external crates cannot override the default
-                    // implementation of `__private_get_type_id__`, since
-                    // it requires returning a private type. We can therefore
-                    // rely on the returned `TypeId`, which ensures that this
-                    // case is correct.
-                    unsafe {
-                        Some(&mut *(self as *const dyn $name as *const T as *mut T))
-                    }
-                } else {
-                    None
-                }
-            }
-        }
-    };
-}
-
-#[cfg(test)]
-mod tests {
-
-    trait MB {
-        downcast_get_type_id!();
-    }
-
-    downcast!(MB);
-
-    impl MB for String {}
-    impl MB for () {}
-
-    #[actix_rt::test]
-    async fn test_any_casting() {
-        let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MB = &mut body;
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast");
-        let body = &mut resp_body.downcast_mut::<String>().unwrap();
-        body.push_str("!");
-        let body = resp_body.downcast_ref::<String>().unwrap();
-        assert_eq!(body, "hello cast!");
-        let not_body = resp_body.downcast_ref::<()>();
-        assert!(not_body.is_none());
-    }
-}
--- a/actix-http/src/message.rs
+++ b/actix-http/src/message.rs
@ -78,13 +78,13 @@ impl Head for RequestHead {
 impl RequestHead {
    /// Message extensions
    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
+    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> {
+    pub fn extensions_mut(&self) -> RefMut<Extensions> {
        self.extensions.borrow_mut()
    }

@ -99,13 +99,13 @@ impl RequestHead {
    }

    /// Is to uppercase headers with Camel-Case.
-    /// Default is `false`
+    /// Befault is `false`
    #[inline]
    pub fn camel_case_headers(&self) -> bool {
        self.flags.contains(Flags::CAMEL_CASE)
    }

-    /// Set `true` to send headers which are formatted as 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 {
@ -237,13 +237,13 @@ impl ResponseHead {

    /// Message extensions
    #[inline]
-    pub fn extensions(&self) -> Ref<'_, Extensions> {
+    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> {
+    pub fn extensions_mut(&self) -> RefMut<Extensions> {
        self.extensions.borrow_mut()
    }

@ -388,12 +388,6 @@ impl BoxedResponseHead {
    pub fn new(status: StatusCode) -> Self {
        RESPONSE_POOL.with(|p| p.get_message(status))
    }
-
-    pub(crate) fn take(&mut self) -> Self {
-        BoxedResponseHead {
-            head: self.head.take(),
-        }
-    }
 }

 impl std::ops::Deref for BoxedResponseHead {
@ -412,9 +406,7 @@ impl std::ops::DerefMut for BoxedResponseHead {

 impl Drop for BoxedResponseHead {
    fn drop(&mut self) {
-        if let Some(head) = self.head.take() {
-            RESPONSE_POOL.with(move |p| p.release(head))
-        }
+        RESPONSE_POOL.with(|p| p.release(self.head.take().unwrap()))
    }
 }

--- a/Show More
+++ b/Show More