Merge pull request #1541 from JohnTitor/backport-files

files: Bump up to 0.2.2
2025-07-06 10:50:17 +02:00 · 2020-05-27 00:37:29 +09:00 · 2020-05-26 17:22:16 +09:00 · 2020-05-26 17:19:12 +09:00 · 2020-05-26 17:18:47 +09:00 · 2020-05-26 17:14:33 +09:00
190 changed files with 10194 additions and 4542 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@ -1,6 +1,6 @@
 ---
-name: Bug Report
-about: Create a bug report.
+name: bug report
+about: create a bug report
 ---

 Your issue may already be reported!
--- 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/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@ -1,24 +0,0 @@
-## PR Type
-What kind of change does this PR make?
-
-<!-- Bug Fix / Feature / Refactor / Code Style / Other -->
-INSERT_PR_TYPE
-
-
-## PR Checklist
-Check your PR fulfills the following:
-
-<!-- For draft PRs check the boxes as you complete them. -->
-
- [ ] Tests for the changes have been added / updated.
- [ ] Documentation comments have been added / updated.
- [ ] A changelog entry has been made for the appropriate packages.
-
-
-## Overview
-<!-- Describe the current and new behavior. -->
-<!-- Emphasize any breaking changes. -->
-
-
-<!-- If this PR fixes or closes an issue, reference it here. -->
-<!-- Closes #000 -->
--- 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
@ -8,7 +8,7 @@ jobs:
      fail-fast: false
      matrix:
        version:
-          - 1.41.1 # MSRV
+          - 1.39.0 # MSRV
          - stable
          - nightly

@ -51,14 +51,3 @@ jobs:
        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 --vers "^0.13"
-          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/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
@ -35,7 +35,6 @@ jobs:
          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:
--- a/CHANGES.md
+++ b/CHANGES.md
@ -1,68 +1,10 @@
 # Changes

-## Unreleased - 2020-xx-xx
-
-
-## 3.0.0-beta.1 - 2020-07-13
-### Added
-* Re-export `actix_rt::main` as `actix_web::main`.
-* `HttpRequest::match_pattern` and `ServiceRequest::match_pattern` for extracting the matched
-  resource pattern.
-* `HttpRequest::match_name` and `ServiceRequest::match_name` for extracting matched resource name.
-
-### Changed
-* Fix actix_http::h1::dispatcher so it returns when HW_BUFFER_SIZE is reached. Should reduce peak memory consumption during large uploads. [#1550]
-* Migrate cookie handling to `cookie` crate. Actix-web no longer requires `ring` dependency.
-* MSRV is now 1.41.1
-
-### Fixed
-* `NormalizePath` improved consistency when path needs slashes added _and_ removed.
-
-
-## 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
+## [2.0.NEXT] - 2020-01-xx

 ### 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
+*  Use `sha-1` crate instead of unmaintained `sha1` crate

 ## [2.0.0] - 2019-12-25

--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "actix-web"
-version = "3.0.0-beta.1"
+version = "2.0.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix web is a simple, pragmatic and extremely fast web framework for Rust."
 readme = "README.md"
@ -11,7 +11,7 @@ documentation = "https://docs.rs/actix-web/"
 categories = ["network-programming", "asynchronous",
              "web-programming::http-server",
              "web-programming::websocket"]
-license = "MIT OR Apache-2.0"
+license = "MIT/Apache-2.0"
 edition = "2018"

 [package.metadata.docs.rs]
@ -30,7 +30,11 @@ members = [
  ".",
  "awc",
  "actix-http",
+  "actix-cors",
  "actix-files",
+  "actix-framed",
+  "actix-session",
+  "actix-identity",
  "actix-multipart",
  "actix-web-actors",
  "actix-web-codegen",
@ -38,77 +42,63 @@ members = [
 ]

 [features]
-default = ["compress"]
+default = ["compress", "failure"]

 # content-encoding support
 compress = ["actix-http/compress", "awc/compress"]

-# sessions feature
+# sessions feature, session require "ring" crate and c compiler
 secure-cookies = ["actix-http/secure-cookies"]

+failure = ["actix-http/failure"]
+
 # openssl
 openssl = ["actix-tls/openssl", "awc/openssl", "open-ssl"]

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

-[[example]]
-name = "basic"
-required-features = ["compress"]
-
-[[example]]
-name = "uds"
-required-features = ["compress"]
-
-[[test]]
-name = "test_server"
-required-features = ["compress"]
-
 [dependencies]
 actix-codec = "0.2.0"
 actix-service = "1.0.2"
 actix-utils = "1.0.6"
 actix-router = "0.2.4"
-actix-rt = "1.1.1"
+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-tls = "1.0.0"

-actix-web-codegen = "0.3.0-beta.1"
-actix-http = "2.0.0-alpha.4"
-awc = { version = "2.0.0-beta.1", default-features = false }
+actix-web-codegen = "0.2.0"
+actix-http = "1.0.1"
+awc = { version = "1.0.1", default-features = false }

 bytes = "0.5.3"
 derive_more = "0.99.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 }
+futures = "0.3.1"
 fxhash = "0.2.1"
 log = "0.4"
 mime = "0.3"
-socket2 = "0.3"
-pin-project = "0.4.17"
+net2 = "0.2.33"
+pin-project = "0.4.6"
 regex = "1.3"
 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 = { package = "openssl", version = "0.10", optional = true }
-rust-tls = { package = "rustls", version = "0.17.0", optional = true }
-tinyvec = { version = "0.3", features = ["alloc"] }
+open-ssl = { version="0.10", package = "openssl", optional = true }
+rust-tls = { version = "0.16.0", package = "rustls", optional = true }

 [dev-dependencies]
-actix = "0.10.0-alpha.1"
+actix = "0.9.0"
 rand = "0.7"
-env_logger = "0.7"
+env_logger = "0.6"
 serde_derive = "1.0"
 brotli2 = "0.3.2"
 flate2 = "1.0.13"
-criterion = "0.3"

 [profile.release]
 lto = true
@ -120,14 +110,9 @@ actix-web = { path = "." }
 actix-http = { path = "actix-http" }
 actix-http-test = { path = "test-server" }
 actix-web-codegen = { path = "actix-web-codegen" }
+actix-cors = { path = "actix-cors" }
+actix-identity = { path = "actix-identity" }
+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,17 +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
@ -366,7 +352,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 +362,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`

--- a/README.md
+++ b/README.md
@ -1,58 +1,52 @@
 <div align="center">
-  <h1>Actix web</h1>
-  <p>
-    <strong>Actix web is a powerful, pragmatic, and extremely fast web framework for Rust</strong>
-  </p>
+ <p><h1>Actix web</h1> </p>
+  <p><strong>Actix web is a small, pragmatic, and extremely fast rust web framework</strong> </p>
  <p>

-[![crates.io](https://meritbadge.herokuapp.com/actix-web)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg)](https://docs.rs/actix-web)
-[![Version](https://img.shields.io/badge/rustc-1.41+-lightgray.svg)](https://blog.rust-lang.org/2020/02/27/Rust-1.41.1.html)
-![License](https://img.shields.io/crates/l/actix-web.svg)
-<br />
 [![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) 
-[![Download](https://img.shields.io/crates/d/actix-web.svg)](https://crates.io/crates/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.39+-lightgray.svg)](https://blog.rust-lang.org/2019/11/07/Rust-1.39.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>

-## Features
+Actix web is a simple, pragmatic and extremely fast web framework for Rust.

-* Supports *HTTP/1.x* and *HTTP/2*
+* Supported *HTTP/1.x* and *HTTP/2.0* protocols
 * Streaming and pipelining
 * Keep-alive and slow requests handling
 * Client/server [WebSockets](https://actix.rs/docs/websockets/) support
 * Transparent content compression/decompression (br, gzip, deflate)
-* Powerful [request routing](https://actix.rs/docs/url-dispatch/)
+* Configurable [request routing](https://actix.rs/docs/url-dispatch/)
 * Multipart streams
 * Static assets
-* SSL support using OpenSSL or Rustls
+* SSL support with OpenSSL or Rustls
 * Middlewares ([Logger, Session, CORS, etc](https://actix.rs/docs/middleware/))
-* Includes an async [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
+* Includes an asynchronous [HTTP client](https://actix.rs/actix-web/actix_web/client/index.html)
 * Supports [Actix actor framework](https://github.com/actix/actix)
-* Runs on stable Rust 1.41+
-
-## Documentation
-
-* [Website & User Guide](https://actix.rs)
-* [Examples Repository](https://actix.rs/actix-web/actix_web)
-* [API Documentation](https://docs.rs/actix-web)
-* [API Documentation (master branch)](https://actix.rs/actix-web/actix_web)

 ## Example

-<h2>
-  WARNING: This example is for the master branch which is currently in beta stages for v3. For
-  Actix web v2 see the <a href="https://actix.rs/docs/getting-started/">getting started guide</a>.
-</h2>
-
 Dependencies:

 ```toml
 [dependencies]
-actix-web = "3"
+actix-web = "2"
+actix-rt = "1"
 ```

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

-#[actix_web::main]
+#[actix_rt::main]
 async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(index))
        .bind("127.0.0.1:8080")?
@ -76,39 +70,37 @@ async fn main() -> std::io::Result<()> {

 ### More examples

-* [Basic Setup](https://github.com/actix/examples/tree/master/basics/)
-* [Application State](https://github.com/actix/examples/tree/master/state/)
-* [JSON Handling](https://github.com/actix/examples/tree/master/json/)
-* [Multipart Streams](https://github.com/actix/examples/tree/master/multipart/)
-* [Diesel Integration](https://github.com/actix/examples/tree/master/diesel/)
-* [r2d2 Integration](https://github.com/actix/examples/tree/master/r2d2/)
-* [Simple WebSocket](https://github.com/actix/examples/tree/master/websocket/)
-* [Tera Templates](https://github.com/actix/examples/tree/master/template_tera/)
-* [Askama Templates](https://github.com/actix/examples/tree/master/template_askama/)
-* [HTTPS using Rustls](https://github.com/actix/examples/tree/master/rustls/)
-* [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/openssl/)
-* [WebSocket Chat](https://github.com/actix/examples/tree/master/websocket-chat/)
+* [Basics](https://github.com/actix/examples/tree/master/basics/)
+* [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
+* [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/)
+* [Tcp/Websocket chat](https://github.com/actix/examples/tree/master/websocket-chat/)
+* [Json](https://github.com/actix/examples/tree/master/json/)

 You may consider checking out
 [this directory](https://github.com/actix/examples/tree/master/) for more examples.

 ## Benchmarks

-One of the fastest web frameworks available according to the
-[TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r19).
+* [TechEmpower Framework Benchmark](https://www.techempower.com/benchmarks/#section=data-r18)

 ## License

 This project is licensed under either of

-* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-  [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
-* MIT license ([LICENSE-MIT](LICENSE-MIT) or
-  [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))
+* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))
+* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT))

 at your option.

 ## Code of Conduct

-Contribution to the actix-web crate is organized under the terms of the Contributor Covenant, the
-maintainers of Actix web, promises to intervene to uphold that code of conduct.
+Contribution to the actix-web crate is organized under the terms of the
+Contributor Covenant, the maintainer of actix-web, @fafhrd91, promises to
+intervene to uphold that code of conduct.
--- a/actix-cors/CHANGES.md
+++ b/actix-cors/CHANGES.md
@ -0,0 +1,15 @@
+# Changes
+
+## [0.2.0] - 2019-12-20
+
+* Release
+
+## [0.2.0-alpha.3] - 2019-12-07
+
+* Migrate to actix-web 2.0.0
+
+* Bump `derive_more` crate version to 0.99.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,26 @@
+[package]
+name = "actix-cors"
+version = "0.2.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 = "2.0.0-rc"
+actix-service = "1.0.1"
+derive_more = "0.99.2"
+futures = "0.3.1"
+
+[dev-dependencies]
+actix-rt = "1.0.0"
--- 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,17 +1,12 @@
 # Changes

-## [unreleased] - xxx
+## [0.2.2] - 2020-05-26

-* Update `v_htmlescape` to 0.10
+* Minimize `futures` dependency
+* Support sending Content-Length when Content-Range is specified [#1496]
+* Update `actix-web` to 2.0.0

-## [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
+[#1496]: https://github.com/actix/actix-web/issues/1496

 ## [0.2.1] - 2019-12-22

--- 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.2.2"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Static files support for actix web."
 readme = "README.md"
@ -9,16 +9,17 @@ homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web.git"
 documentation = "https://docs.rs/actix-files/"
 categories = ["asynchronous", "web-programming::http-server"]
-license = "MIT OR Apache-2.0"
+license = "MIT/Apache-2.0"
 edition = "2018"
+workspace = ".."

 [lib]
 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-web = { version = "2.0.0", default-features = false }
+actix-http = "1.0.1"
 actix-service = "1.0.1"
 bitflags = "1"
 bytes = "0.5.3"
@ -29,8 +30,8 @@ log = "0.4"
 mime = "0.3"
 mime_guess = "2.0.1"
 percent-encoding = "2.1"
-v_htmlescape = "0.10"
+v_htmlescape = "0.4"

 [dev-dependencies]
 actix-rt = "1.0.0"
-actix-web = { version = "3.0.0-alpha.3", features = ["openssl"] }
+actix-web = { version = "2.0.0", features = ["openssl"] }
--- 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-framed/Cargo.toml
+++ b/actix-framed/Cargo.toml
@ -0,0 +1,37 @@
+[package]
+name = "actix-framed"
+version = "0.3.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Actix framed app server"
+readme = "README.md"
+keywords = ["http", "web", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-framed/"
+categories = ["network-programming", "asynchronous",
+              "web-programming::http-server",
+              "web-programming::websocket"]
+license = "MIT/Apache-2.0"
+edition = "2018"
+
+[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 = "1.0.1"
+
+bytes = "0.5.3"
+futures = "0.3.1"
+pin-project = "0.4.6"
+log = "0.4"
+
+[dev-dependencies]
+actix-server = "1.0.0"
+actix-connect = { version = "1.0.0", features=["openssl"] }
+actix-http-test = { version = "1.0.0", features=["openssl"] }
+actix-utils = "1.0.3"
--- a/actix-framed/LICENSE-APACHE
+++ b/actix-framed/LICENSE-APACHE
@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2017-NOW Nikolay Kim
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/actix-framed/LICENSE-MIT
+++ b/actix-framed/LICENSE-MIT
@ -0,0 +1,25 @@
+Copyright (c) 2017 Nikolay Kim
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
--- a/actix-framed/README.md
+++ b/actix-framed/README.md
@ -1,3 +1,10 @@
-# Framed app for actix web
+# Framed app for actix web [![Build Status](https://travis-ci.org/actix/actix-web.svg?branch=master)](https://travis-ci.org/actix/actix-web) [![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web) [![crates.io](https://meritbadge.herokuapp.com/actix-framed)](https://crates.io/crates/actix-framed) [![Join the chat at https://gitter.im/actix/actix](https://badges.gitter.im/actix/actix.svg)](https://gitter.im/actix/actix?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

-**This crate has been deprecated and removed.**
+**Notice**: `actix-framed` is deprecated since we don't use it anymore.
+
+## Documentation & community resources
+
+* [API Documentation](https://docs.rs/actix-framed/)
+* [Chat on gitter](https://gitter.im/actix/actix)
+* Cargo package: [actix-framed](https://crates.io/crates/actix-framed)
+* Minimum supported Rust version: 1.33 or later
--- a/actix-framed/changes.md
+++ b/actix-framed/changes.md
@ -0,0 +1,28 @@
+# Changes
+
+## [0.3.1] - 2020-05-25
+
+* Deprecate this crate
+
+## [0.3.0] - 2019-12-25
+
+* Migrate to actix-http 1.0
+
+## [0.2.1] - 2019-07-20
+
+* Remove unneeded actix-utils dependency
+
+
+## [0.2.0] - 2019-05-12
+
+* Update dependencies
+
+
+## [0.1.0] - 2019-04-16
+
+* Update tests
+
+
+## [0.1.0-alpha.1] - 2019-04-12
+
+* Initial release
--- a/actix-framed/src/app.rs
+++ b/actix-framed/src/app.rs
@ -0,0 +1,221 @@
+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::future::{ok, FutureExt, LocalBoxFuture};
+
+use crate::helpers::{BoxedHttpNewService, BoxedHttpService, HttpNewService};
+use crate::request::FramedRequest;
+use crate::state::State;
+
+type BoxedResponse = LocalBoxFuture<'static, Result<(), Error>>;
+
+pub trait HttpServiceFactory {
+    type Factory: ServiceFactory;
+
+    fn path(&self) -> &str;
+
+    fn create(self) -> Self::Factory;
+}
+
+/// Application builder
+pub struct FramedApp<T, S = ()> {
+    state: State<S>,
+    services: Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>,
+}
+
+impl<T: 'static> FramedApp<T, ()> {
+    pub fn new() -> Self {
+        FramedApp {
+            state: State::new(()),
+            services: Vec::new(),
+        }
+    }
+}
+
+impl<T: 'static, S: 'static> FramedApp<T, S> {
+    pub fn with(state: S) -> FramedApp<T, S> {
+        FramedApp {
+            services: Vec::new(),
+            state: State::new(state),
+        }
+    }
+
+    pub fn service<U>(mut self, factory: U) -> Self
+    where
+        U: HttpServiceFactory,
+        U::Factory: ServiceFactory<
+                Config = (),
+                Request = FramedRequest<T, S>,
+                Response = (),
+                Error = Error,
+                InitError = (),
+            > + 'static,
+        <U::Factory as ServiceFactory>::Future: 'static,
+        <U::Factory as ServiceFactory>::Service: Service<
+            Request = FramedRequest<T, S>,
+            Response = (),
+            Error = Error,
+            Future = LocalBoxFuture<'static, Result<(), Error>>,
+        >,
+    {
+        let path = factory.path().to_string();
+        self.services
+            .push((path, Box::new(HttpNewService::new(factory.create()))));
+        self
+    }
+}
+
+impl<T, S> IntoServiceFactory<FramedAppFactory<T, S>> for FramedApp<T, S>
+where
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    S: 'static,
+{
+    fn into_factory(self) -> FramedAppFactory<T, S> {
+        FramedAppFactory {
+            state: self.state,
+            services: Rc::new(self.services),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct FramedAppFactory<T, S> {
+    state: State<S>,
+    services: Rc<Vec<(String, BoxedHttpNewService<FramedRequest<T, S>>)>>,
+}
+
+impl<T, S> ServiceFactory for FramedAppFactory<T, S>
+where
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    S: 'static,
+{
+    type Config = ();
+    type Request = (Request, Framed<T, Codec>);
+    type Response = ();
+    type Error = Error;
+    type InitError = ();
+    type Service = FramedAppService<T, S>;
+    type Future = CreateService<T, S>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        CreateService {
+            fut: self
+                .services
+                .iter()
+                .map(|(path, service)| {
+                    CreateServiceItem::Future(
+                        Some(path.clone()),
+                        service.new_service(()),
+                    )
+                })
+                .collect(),
+            state: self.state.clone(),
+        }
+    }
+}
+
+#[doc(hidden)]
+pub struct CreateService<T, S> {
+    fut: Vec<CreateServiceItem<T, S>>,
+    state: State<S>,
+}
+
+enum CreateServiceItem<T, S> {
+    Future(
+        Option<String>,
+        LocalBoxFuture<'static, Result<BoxedHttpService<FramedRequest<T, S>>, ()>>,
+    ),
+    Service(String, BoxedHttpService<FramedRequest<T, S>>),
+}
+
+impl<S: 'static, T: 'static> Future for CreateService<T, S>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    type Output = Result<FramedAppService<T, S>, ()>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        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 => {
+                            done = false;
+                            None
+                        }
+                    }
+                }
+                CreateServiceItem::Service(_, _) => continue,
+            };
+
+            if let Some((path, service)) = res {
+                *item = CreateServiceItem::Service(path, service);
+            }
+        }
+
+        if done {
+            let router = self
+                .fut
+                .drain(..)
+                .fold(Router::build(), |mut router, item| {
+                    match item {
+                        CreateServiceItem::Service(path, service) => {
+                            router.path(&path, service);
+                        }
+                        CreateServiceItem::Future(_, _) => unreachable!(),
+                    }
+                    router
+                });
+            Poll::Ready(Ok(FramedAppService {
+                router: router.finish(),
+                state: self.state.clone(),
+            }))
+        } else {
+            Poll::Pending
+        }
+    }
+}
+
+pub struct FramedAppService<T, S> {
+    state: State<S>,
+    router: Router<BoxedHttpService<FramedRequest<T, S>>>,
+}
+
+impl<S: 'static, T: 'static> Service for FramedAppService<T, S>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    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 call(&mut self, (req, framed): (Request, Framed<T, Codec>)) -> Self::Future {
+        let mut path = Path::new(Url::new(req.uri().clone()));
+
+        if let Some((srv, _info)) = self.router.recognize_mut(&mut path) {
+            return srv.call(FramedRequest::new(req, framed, path, self.state.clone()));
+        }
+        SendResponse::new(framed, Response::NotFound().finish())
+            .then(|_| ok(()))
+            .boxed_local()
+    }
+}
--- a/actix-framed/src/helpers.rs
+++ b/actix-framed/src/helpers.rs
@ -0,0 +1,98 @@
+use std::task::{Context, Poll};
+
+use actix_http::Error;
+use actix_service::{Service, ServiceFactory};
+use futures::future::{FutureExt, LocalBoxFuture};
+
+pub(crate) type BoxedHttpService<Req> = Box<
+    dyn Service<
+        Request = Req,
+        Response = (),
+        Error = Error,
+        Future = LocalBoxFuture<'static, Result<(), Error>>,
+    >,
+>;
+
+pub(crate) type BoxedHttpNewService<Req> = Box<
+    dyn ServiceFactory<
+        Config = (),
+        Request = Req,
+        Response = (),
+        Error = Error,
+        InitError = (),
+        Service = BoxedHttpService<Req>,
+        Future = LocalBoxFuture<'static, Result<BoxedHttpService<Req>, ()>>,
+    >,
+>;
+
+pub(crate) struct HttpNewService<T: ServiceFactory>(T);
+
+impl<T> HttpNewService<T>
+where
+    T: ServiceFactory<Response = (), Error = Error>,
+    T::Response: 'static,
+    T::Future: 'static,
+    T::Service: Service<Future = LocalBoxFuture<'static, Result<(), Error>>> + 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    pub fn new(service: T) -> Self {
+        HttpNewService(service)
+    }
+}
+
+impl<T> ServiceFactory for HttpNewService<T>
+where
+    T: ServiceFactory<Config = (), Response = (), Error = Error>,
+    T::Request: 'static,
+    T::Future: 'static,
+    T::Service: Service<Future = LocalBoxFuture<'static, Result<(), Error>>> + 'static,
+    <T::Service as Service>::Future: 'static,
+{
+    type Config = ();
+    type Request = T::Request;
+    type Response = ();
+    type Error = Error;
+    type InitError = ();
+    type Service = BoxedHttpService<T::Request>;
+    type Future = LocalBoxFuture<'static, Result<Self::Service, ()>>;
+
+    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()
+    }
+}
+
+struct HttpServiceWrapper<T: Service> {
+    service: T,
+}
+
+impl<T> Service for HttpServiceWrapper<T>
+where
+    T: Service<
+        Response = (),
+        Future = LocalBoxFuture<'static, Result<(), Error>>,
+        Error = Error,
+    >,
+    T::Request: 'static,
+{
+    type Request = T::Request;
+    type Response = ();
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<(), Error>>;
+
+    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        self.service.call(req)
+    }
+}
--- a/actix-framed/src/lib.rs
+++ b/actix-framed/src/lib.rs
@ -0,0 +1,17 @@
+#![allow(clippy::type_complexity, clippy::new_without_default, dead_code)]
+mod app;
+mod helpers;
+mod request;
+mod route;
+mod service;
+mod state;
+pub mod test;
+
+// re-export for convinience
+pub use actix_http::{http, Error, HttpMessage, Response, ResponseError};
+
+pub use self::app::{FramedApp, FramedAppService};
+pub use self::request::FramedRequest;
+pub use self::route::FramedRoute;
+pub use self::service::{SendError, VerifyWebSockets};
+pub use self::state::State;
--- a/actix-framed/src/request.rs
+++ b/actix-framed/src/request.rs
@ -0,0 +1,172 @@
+use std::cell::{Ref, RefMut};
+
+use actix_codec::Framed;
+use actix_http::http::{HeaderMap, Method, Uri, Version};
+use actix_http::{h1::Codec, Extensions, Request, RequestHead};
+use actix_router::{Path, Url};
+
+use crate::state::State;
+
+pub struct FramedRequest<Io, S = ()> {
+    req: Request,
+    framed: Framed<Io, Codec>,
+    state: State<S>,
+    pub(crate) path: Path<Url>,
+}
+
+impl<Io, S> FramedRequest<Io, S> {
+    pub fn new(
+        req: Request,
+        framed: Framed<Io, Codec>,
+        path: Path<Url>,
+        state: State<S>,
+    ) -> Self {
+        Self {
+            req,
+            framed,
+            state,
+            path,
+        }
+    }
+}
+
+impl<Io, S> FramedRequest<Io, S> {
+    /// Split request into a parts
+    pub fn into_parts(self) -> (Request, Framed<Io, Codec>, State<S>) {
+        (self.req, self.framed, self.state)
+    }
+
+    /// This method returns reference to the request head
+    #[inline]
+    pub fn head(&self) -> &RequestHead {
+        self.req.head()
+    }
+
+    /// This method returns muttable reference to the request head.
+    /// panics if multiple references of http request exists.
+    #[inline]
+    pub fn head_mut(&mut self) -> &mut RequestHead {
+        self.req.head_mut()
+    }
+
+    /// Shared application state
+    #[inline]
+    pub fn state(&self) -> &S {
+        self.state.get_ref()
+    }
+
+    /// Request's uri.
+    #[inline]
+    pub fn uri(&self) -> &Uri {
+        &self.head().uri
+    }
+
+    /// Read the Request method.
+    #[inline]
+    pub fn method(&self) -> &Method {
+        &self.head().method
+    }
+
+    /// Read the Request Version.
+    #[inline]
+    pub fn version(&self) -> Version {
+        self.head().version
+    }
+
+    #[inline]
+    /// Returns request's headers.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.head().headers
+    }
+
+    /// The target path of this Request.
+    #[inline]
+    pub fn path(&self) -> &str {
+        self.head().uri.path()
+    }
+
+    /// The query string in the URL.
+    ///
+    /// E.g., id=10
+    #[inline]
+    pub fn query_string(&self) -> &str {
+        if let Some(query) = self.uri().query().as_ref() {
+            query
+        } else {
+            ""
+        }
+    }
+
+    /// Get a reference to the Path parameters.
+    ///
+    /// Params is a container for url parameters.
+    /// A variable segment is specified in the form `{identifier}`,
+    /// where the identifier can be used later in a request handler to
+    /// access the matched value for that segment.
+    #[inline]
+    pub fn match_info(&self) -> &Path<Url> {
+        &self.path
+    }
+
+    /// Request extensions
+    #[inline]
+    pub fn extensions(&self) -> Ref<Extensions> {
+        self.head().extensions()
+    }
+
+    /// Mutable reference to a the request's extensions
+    #[inline]
+    pub fn extensions_mut(&self) -> RefMut<Extensions> {
+        self.head().extensions_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::convert::TryFrom;
+
+    use actix_http::http::{HeaderName, HeaderValue};
+    use actix_http::test::{TestBuffer, TestRequest};
+
+    use super::*;
+
+    #[test]
+    fn test_reqest() {
+        let buf = TestBuffer::empty();
+        let framed = Framed::new(buf, Codec::default());
+        let req = TestRequest::with_uri("/index.html?q=1")
+            .header("content-type", "test")
+            .finish();
+        let path = Path::new(Url::new(req.uri().clone()));
+
+        let mut freq = FramedRequest::new(req, framed, path, State::new(10u8));
+        assert_eq!(*freq.state(), 10);
+        assert_eq!(freq.version(), Version::HTTP_11);
+        assert_eq!(freq.method(), Method::GET);
+        assert_eq!(freq.path(), "/index.html");
+        assert_eq!(freq.query_string(), "q=1");
+        assert_eq!(
+            freq.headers()
+                .get("content-type")
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "test"
+        );
+
+        freq.head_mut().headers.insert(
+            HeaderName::try_from("x-hdr").unwrap(),
+            HeaderValue::from_static("test"),
+        );
+        assert_eq!(
+            freq.headers().get("x-hdr").unwrap().to_str().unwrap(),
+            "test"
+        );
+
+        freq.extensions_mut().insert(100usize);
+        assert_eq!(*freq.extensions().get::<usize>().unwrap(), 100usize);
+
+        let (_, _, state) = freq.into_parts();
+        assert_eq!(*state, 10);
+    }
+}
--- a/actix-framed/src/route.rs
+++ b/actix-framed/src/route.rs
@ -0,0 +1,159 @@
+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::future::{ok, FutureExt, LocalBoxFuture, Ready};
+use log::error;
+
+use crate::app::HttpServiceFactory;
+use crate::request::FramedRequest;
+
+/// Resource route definition
+///
+/// Route uses builder-like pattern for configuration.
+/// If handler is not explicitly set, default *404 Not Found* handler is used.
+pub struct FramedRoute<Io, S, F = (), R = (), E = ()> {
+    handler: F,
+    pattern: String,
+    methods: Vec<Method>,
+    state: PhantomData<(Io, S, R, E)>,
+}
+
+impl<Io, S> FramedRoute<Io, S> {
+    pub fn new(pattern: &str) -> Self {
+        FramedRoute {
+            handler: (),
+            pattern: pattern.to_string(),
+            methods: Vec::new(),
+            state: PhantomData,
+        }
+    }
+
+    pub fn get(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::GET)
+    }
+
+    pub fn post(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::POST)
+    }
+
+    pub fn put(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::PUT)
+    }
+
+    pub fn delete(path: &str) -> FramedRoute<Io, S> {
+        FramedRoute::new(path).method(Method::DELETE)
+    }
+
+    pub fn method(mut self, method: Method) -> Self {
+        self.methods.push(method);
+        self
+    }
+
+    pub fn to<F, R, E>(self, handler: F) -> FramedRoute<Io, S, F, R, E>
+    where
+        F: FnMut(FramedRequest<Io, S>) -> R,
+        R: Future<Output = Result<(), E>> + 'static,
+
+        E: fmt::Debug,
+    {
+        FramedRoute {
+            handler,
+            pattern: self.pattern,
+            methods: self.methods,
+            state: PhantomData,
+        }
+    }
+}
+
+impl<Io, S, F, R, E> HttpServiceFactory for FramedRoute<Io, S, F, R, E>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
+    R: Future<Output = Result<(), E>> + 'static,
+    E: fmt::Display,
+{
+    type Factory = FramedRouteFactory<Io, S, F, R, E>;
+
+    fn path(&self) -> &str {
+        &self.pattern
+    }
+
+    fn create(self) -> Self::Factory {
+        FramedRouteFactory {
+            handler: self.handler,
+            methods: self.methods,
+            _t: PhantomData,
+        }
+    }
+}
+
+pub struct FramedRouteFactory<Io, S, F, R, E> {
+    handler: F,
+    methods: Vec<Method>,
+    _t: PhantomData<(Io, S, R, E)>,
+}
+
+impl<Io, S, F, R, E> ServiceFactory for FramedRouteFactory<Io, S, F, R, E>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
+    R: Future<Output = Result<(), E>> + 'static,
+    E: 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>>;
+
+    fn new_service(&self, _: ()) -> Self::Future {
+        ok(FramedRouteService {
+            handler: self.handler.clone(),
+            methods: self.methods.clone(),
+            _t: PhantomData,
+        })
+    }
+}
+
+pub struct FramedRouteService<Io, S, F, R, E> {
+    handler: F,
+    methods: Vec<Method>,
+    _t: PhantomData<(Io, S, R, E)>,
+}
+
+impl<Io, S, F, R, E> Service for FramedRouteService<Io, S, F, R, E>
+where
+    Io: AsyncRead + AsyncWrite + 'static,
+    F: FnMut(FramedRequest<Io, S>) -> R + Clone,
+    R: Future<Output = Result<(), E>> + 'static,
+    E: fmt::Display,
+{
+    type Request = FramedRequest<Io, S>;
+    type Response = ();
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<(), Error>>;
+
+    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: FramedRequest<Io, S>) -> Self::Future {
+        let fut = (self.handler)(req);
+
+        async move {
+            let res = fut.await;
+            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
@ -0,0 +1,156 @@
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use actix_codec::{AsyncRead, AsyncWrite, Framed};
+use actix_http::body::BodySize;
+use actix_http::error::ResponseError;
+use actix_http::h1::{Codec, Message};
+use actix_http::ws::{verify_handshake, HandshakeError};
+use actix_http::{Request, Response};
+use actix_service::{Service, ServiceFactory};
+use futures::future::{err, ok, Either, Ready};
+use futures::Future;
+
+/// Service that verifies incoming request if it is valid websocket
+/// upgrade request. In case of error returns `HandshakeError`
+pub struct VerifyWebSockets<T, C> {
+    _t: PhantomData<(T, C)>,
+}
+
+impl<T, C> Default for VerifyWebSockets<T, C> {
+    fn default() -> Self {
+        VerifyWebSockets { _t: PhantomData }
+    }
+}
+
+impl<T, C> ServiceFactory 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>>;
+
+    fn new_service(&self, _: C) -> Self::Future {
+        ok(VerifyWebSockets { _t: PhantomData })
+    }
+}
+
+impl<T, C> Service for VerifyWebSockets<T, C> {
+    type Request = (Request, Framed<T, Codec>);
+    type Response = (Request, Framed<T, Codec>);
+    type Error = (HandshakeError, Framed<T, Codec>);
+    type Future = Ready<Result<Self::Response, Self::Error>>;
+
+    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    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)),
+        }
+    }
+}
+
+/// Send http/1 error response
+pub struct SendError<T, R, E, C>(PhantomData<(T, R, E, C)>);
+
+impl<T, R, E, C> Default for SendError<T, R, E, C>
+where
+    T: AsyncRead + AsyncWrite,
+    E: ResponseError,
+{
+    fn default() -> Self {
+        SendError(PhantomData)
+    }
+}
+
+impl<T, R, E, C> ServiceFactory for SendError<T, R, E, C>
+where
+    T: AsyncRead + AsyncWrite + Unpin + 'static,
+    R: 'static,
+    E: ResponseError + 'static,
+{
+    type Config = C;
+    type Request = Result<R, (E, Framed<T, Codec>)>;
+    type Response = R;
+    type Error = (E, Framed<T, Codec>);
+    type InitError = ();
+    type Service = SendError<T, R, E, C>;
+    type Future = Ready<Result<Self::Service, Self::InitError>>;
+
+    fn new_service(&self, _: C) -> Self::Future {
+        ok(SendError(PhantomData))
+    }
+}
+
+impl<T, R, E, C> Service for SendError<T, R, E, C>
+where
+    T: AsyncRead + AsyncWrite + Unpin + '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>>;
+
+    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Result<R, (E, Framed<T, Codec>)>) -> Self::Future {
+        match req {
+            Ok(r) => Either::Left(ok(r)),
+            Err((e, framed)) => {
+                let res = e.error_response().drop_body();
+                Either::Right(SendErrorFut {
+                    framed: Some(framed),
+                    res: Some((res, BodySize::Empty).into()),
+                    err: Some(e),
+                    _t: PhantomData,
+                })
+            }
+        }
+    }
+}
+
+#[pin_project::pin_project]
+pub struct SendErrorFut<T, R, E> {
+    res: Option<Message<(Response<()>, BodySize)>>,
+    framed: Option<Framed<T, Codec>>,
+    err: Option<E>,
+    _t: PhantomData<R>,
+}
+
+impl<T, R, E> Future for SendErrorFut<T, R, E>
+where
+    E: ResponseError,
+    T: AsyncRead + AsyncWrite + Unpin,
+{
+    type Output = Result<R, (E, Framed<T, Codec>)>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        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(),
+                )));
+            }
+        }
+        match self.framed.as_mut().unwrap().flush(cx) {
+            Poll::Ready(Ok(_)) => {
+                Poll::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,
+        }
+    }
+}
--- a/actix-framed/src/state.rs
+++ b/actix-framed/src/state.rs
@ -0,0 +1,29 @@
+use std::ops::Deref;
+use std::sync::Arc;
+
+/// Application state
+pub struct State<S>(Arc<S>);
+
+impl<S> State<S> {
+    pub fn new(state: S) -> State<S> {
+        State(Arc::new(state))
+    }
+
+    pub fn get_ref(&self) -> &S {
+        self.0.as_ref()
+    }
+}
+
+impl<S> Deref for State<S> {
+    type Target = S;
+
+    fn deref(&self) -> &S {
+        self.0.as_ref()
+    }
+}
+
+impl<S> Clone for State<S> {
+    fn clone(&self) -> State<S> {
+        State(self.0.clone())
+    }
+}
--- a/actix-framed/src/test.rs
+++ b/actix-framed/src/test.rs
@ -0,0 +1,155 @@
+//! 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::test::{TestBuffer, TestRequest as HttpTestRequest};
+use actix_router::{Path, Url};
+
+use crate::{FramedRequest, State};
+
+/// Test `Request` builder.
+pub struct TestRequest<S = ()> {
+    req: HttpTestRequest,
+    path: Path<Url>,
+    state: State<S>,
+}
+
+impl Default for TestRequest<()> {
+    fn default() -> TestRequest {
+        TestRequest {
+            req: HttpTestRequest::default(),
+            path: Path::new(Url::new(Uri::default())),
+            state: State::new(()),
+        }
+    }
+}
+
+impl TestRequest<()> {
+    /// Create TestRequest and set request uri
+    pub fn with_uri(path: &str) -> Self {
+        Self::get().uri(path)
+    }
+
+    /// Create TestRequest and set header
+    pub fn with_hdr<H: Header>(hdr: H) -> Self {
+        Self::default().set(hdr)
+    }
+
+    /// Create TestRequest and set header
+    pub fn with_header<K, V>(key: K, value: V) -> Self
+    where
+        HeaderName: TryFrom<K>,
+        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
+        V: IntoHeaderValue,
+    {
+        Self::default().header(key, value)
+    }
+
+    /// Create TestRequest and set method to `Method::GET`
+    pub fn get() -> Self {
+        Self::default().method(Method::GET)
+    }
+
+    /// Create TestRequest and set method to `Method::POST`
+    pub fn post() -> Self {
+        Self::default().method(Method::POST)
+    }
+}
+
+impl<S> TestRequest<S> {
+    /// Create TestRequest and set request uri
+    pub fn with_state(state: S) -> TestRequest<S> {
+        let req = TestRequest::get();
+        TestRequest {
+            state: State::new(state),
+            req: req.req,
+            path: req.path,
+        }
+    }
+
+    /// Set HTTP version of this request
+    pub fn version(mut self, ver: Version) -> Self {
+        self.req.version(ver);
+        self
+    }
+
+    /// Set HTTP method of this request
+    pub fn method(mut self, meth: Method) -> Self {
+        self.req.method(meth);
+        self
+    }
+
+    /// Set HTTP Uri of this request
+    pub fn uri(mut self, path: &str) -> Self {
+        self.req.uri(path);
+        self
+    }
+
+    /// Set a header
+    pub fn set<H: Header>(mut self, hdr: H) -> Self {
+        self.req.set(hdr);
+        self
+    }
+
+    /// Set a header
+    pub fn header<K, V>(mut self, key: K, value: V) -> Self
+    where
+        HeaderName: TryFrom<K>,
+        <HeaderName as TryFrom<K>>::Error: Into<HttpError>,
+        V: IntoHeaderValue,
+    {
+        self.req.header(key, value);
+        self
+    }
+
+    /// Set request path pattern parameter
+    pub fn param(mut self, name: &'static str, value: &'static str) -> Self {
+        self.path.add_static(name, value);
+        self
+    }
+
+    /// Complete request creation and generate `Request` instance
+    pub fn finish(mut self) -> FramedRequest<TestBuffer, S> {
+        let req = self.req.finish();
+        self.path.get_mut().update(req.uri());
+        let framed = Framed::new(TestBuffer::empty(), Codec::default());
+        FramedRequest::new(req, framed, self.path, self.state)
+    }
+
+    /// This method generates `FramedRequest` instance and executes async handler
+    pub async 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>>,
+    {
+        f(self.finish()).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test() {
+        let req = TestRequest::with_uri("/index.html")
+            .header("x-test", "test")
+            .param("test", "123")
+            .finish();
+
+        assert_eq!(*req.state(), ());
+        assert_eq!(req.version(), Version::HTTP_11);
+        assert_eq!(req.method(), Method::GET);
+        assert_eq!(req.path(), "/index.html");
+        assert_eq!(req.query_string(), "");
+        assert_eq!(
+            req.headers().get("x-test").unwrap().to_str().unwrap(),
+            "test"
+        );
+        assert_eq!(&req.match_info()["test"], "123");
+    }
+}
--- a/actix-framed/tests/test_server.rs
+++ b/actix-framed/tests/test_server.rs
@ -0,0 +1,159 @@
+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::{future, SinkExt, StreamExt};
+
+use actix_framed::{FramedApp, FramedRequest, FramedRoute, SendError, VerifyWebSockets};
+
+async fn ws_service<T: AsyncRead + AsyncWrite>(
+    req: FramedRequest<T>,
+) -> Result<(), Error> {
+    let (req, mut 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(())
+}
+
+async fn service(msg: ws::Frame) -> Result<ws::Message, 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::Frame::Binary(bin) => ws::Message::Binary(bin),
+        ws::Frame::Close(reason) => ws::Message::Close(reason),
+        _ => panic!(),
+    };
+    Ok(msg)
+}
+
+#[actix_rt::test]
+async fn test_simple() {
+    let mut srv = test_server(|| {
+        HttpService::build()
+            .upgrade(
+                FramedApp::new().service(FramedRoute::get("/index.html").to(ws_service)),
+            )
+            .finish(|_| future::ok::<_, Error>(Response::NotFound()))
+            .tcp()
+    });
+
+    assert!(srv.ws_at("/test").await.is_err());
+
+    // client service
+    let mut framed = srv.ws_at("/index.html").await.unwrap();
+    framed
+        .send(ws::Message::Text("text".to_string()))
+        .await
+        .unwrap();
+    let (item, mut framed) = framed.into_future().await;
+    assert_eq!(
+        item.unwrap().unwrap(),
+        ws::Frame::Text(Bytes::from_static(b"text"))
+    );
+
+    framed
+        .send(ws::Message::Binary("text".into()))
+        .await
+        .unwrap();
+    let (item, mut framed) = framed.into_future().await;
+    assert_eq!(
+        item.unwrap().unwrap(),
+        ws::Frame::Binary(Bytes::from_static(b"text"))
+    );
+
+    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
+        .unwrap();
+
+    let (item, _) = framed.into_future().await;
+    assert_eq!(
+        item.unwrap().unwrap(),
+        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(|_| ()),
+            ),
+        )
+    });
+
+    // non ws request
+    let res = srv.get("/index.html").send().await.unwrap();
+    assert_eq!(res.status(), StatusCode::BAD_REQUEST);
+
+    // not found
+    assert!(srv.ws_at("/test").await.is_err());
+
+    // client service
+    let mut framed = srv.ws_at("/index.html").await.unwrap();
+    framed
+        .send(ws::Message::Text("text".to_string()))
+        .await
+        .unwrap();
+    let (item, mut framed) = framed.into_future().await;
+    assert_eq!(
+        item.unwrap().unwrap(),
+        ws::Frame::Text(Bytes::from_static(b"text"))
+    );
+
+    framed
+        .send(ws::Message::Binary("text".into()))
+        .await
+        .unwrap();
+    let (item, mut framed) = framed.into_future().await;
+    assert_eq!(
+        item.unwrap().unwrap(),
+        ws::Frame::Binary(Bytes::from_static(b"text"))
+    );
+
+    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
+        .unwrap();
+
+    let (item, _) = framed.into_future().await;
+    assert_eq!(
+        item.unwrap().unwrap(),
+        ws::Frame::Close(Some(ws::CloseCode::Normal.into()))
+    );
+}
--- a/actix-http/.appveyor.yml
+++ b/actix-http/.appveyor.yml
@ -0,0 +1,41 @@
+environment:
+  global:
+    PROJECT_NAME: actix-http
+  matrix:
+    # Stable channel
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: stable
+    # Nightly channel
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: nightly
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: nightly
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: nightly
+
+# Install Rust and Cargo
+# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
+install:
+  - ps: >-
+        If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
+           $Env:PATH += ';C:\msys64\mingw64\bin'
+        } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
+           $Env:PATH += ';C:\MinGW\bin'
+        }
+  - curl -sSf -o rustup-init.exe https://win.rustup.rs
+  - rustup-init.exe --default-host %TARGET% --default-toolchain %CHANNEL% -y
+  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
+  - rustc -Vv
+  - cargo -V
+
+# 'cargo test' takes care of building for us, so disable Appveyor's build stage.
+build: false
+
+# Equivalent to Travis' `script` phase
+test_script:
+  - cargo clean
+  - cargo test
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@ -1,83 +1,5 @@
 # Changes

-## [Unreleased] - xxx
-
-## [2.0.0-beta.1] - 2020-07-11
-
-### Changed
-
-* Migrate cookie handling to `cookie` crate. [#1558]
-* Update `sha-1` to 0.9. [#1586]
-* Fix leak in client pool. [#1580]
-* MSRV is now 1.41.1.
-
-[#1558]: https://github.com/actix/actix-web/pull/1558
-[#1586]: https://github.com/actix/actix-web/pull/1586
-[#1580]: https://github.com/actix/actix-web/pull/1580
-
-## [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
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@ -1,8 +1,8 @@
 [package]
 name = "actix-http"
-version = "2.0.0-beta.1"
+version = "1.0.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
-description = "Actix HTTP primitives"
+description = "Actix http primitives"
 readme = "README.md"
 keywords = ["actix", "http", "framework", "async", "futures"]
 homepage = "https://actix.rs"
@ -11,11 +11,11 @@ documentation = "https://docs.rs/actix-http/"
 categories = ["network-programming", "asynchronous",
              "web-programming::http-server",
              "web-programming::websocket"]
-license = "MIT OR Apache-2.0"
+license = "MIT/Apache-2.0"
 edition = "2018"

 [package.metadata.docs.rs]
-features = ["openssl", "rustls", "compress", "secure-cookies", "actors"]
+features = ["openssl", "rustls", "failure", "compress", "secure-cookies"]

 [lib]
 name = "actix_http"
@ -33,73 +33,69 @@ rustls = ["actix-tls/rustls", "actix-connect/rustls"]
 # enable compressison support
 compress = ["flate2", "brotli2"]

-# support for secure cookies
-secure-cookies = ["cookie/secure"]
+# failure integration. actix does not use failure anymore
+failure = ["fail-ure"]

-# support for actix Actor messages
-actors = ["actix"]
+# support for secure cookies
+secure-cookies = ["ring"]

 [dependencies]
-actix-service = "1.0.5"
+actix-service = "1.0.1"
 actix-codec = "0.2.0"
-actix-connect = "2.0.0-alpha.3"
-actix-utils = "1.0.6"
+actix-connect = "1.0.1"
+actix-utils = "1.0.3"
 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-tls = { version = "1.0.0", optional = true }

-base64 = "0.12"
+base64 = "0.11"
 bitflags = "1.2"
 bytes = "0.5.3"
-cookie = { version = "0.14.1", features = ["percent-encode"] }
 copyless = "0.1.4"
+chrono = "0.4.6"
 derive_more = "0.99.2"
 either = "1.5.3"
 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 }
+futures-core = "0.3.1"
+futures-util = "0.3.1"
+futures-channel = "0.3.1"
 fxhash = "0.2.1"
 h2 = "0.2.1"
 http = "0.2.0"
 httparse = "1.3"
 indexmap = "1.3"
-itoa = "0.4"
 lazy_static = "1.4"
 language-tags = "0.2"
 log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
-pin-project = "0.4.17"
+pin-project = "0.4.6"
 rand = "0.7"
 regex = "1.3"
 serde = "1.0"
 serde_json = "1.0"
-sha-1 = "0.9"
+sha-1 = "0.8"
 slab = "0.4"
 serde_urlencoded = "0.6.1"
-time = { version = "0.2.7", default-features = false, features = ["std"] }
+time = "0.1.42"
+
+# for secure cookie
+ring = { version = "0.16.9", optional = true }

 # compression
 brotli2 = { version="0.3.2", optional = true }
 flate2 = { version = "1.0.13", optional = true }

+# optional deps
+fail-ure = { version = "0.1.5", package="failure", optional = true }
+
 [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-server = "1.0.0"
+actix-connect = { version = "1.0.0", features=["openssl"] }
+actix-http-test = { version = "1.0.0", features=["openssl"] }
+actix-tls = { version = "1.0.0", features=["openssl"] }
+futures = "0.3.1"
+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
+rust-tls = { version="0.16", package = "rustls" }
--- 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
@ -3,7 +3,7 @@ use std::{env, io};
 use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures_util::StreamExt;
+use futures::StreamExt;
 use http::header::HeaderValue;
 use log::info;

@ -17,18 +17,23 @@ 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?);
-                    }
+                .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),
-                    )
+                        info!("request body: {:?}", body);
+                        Ok::<_, Error>(
+                            Response::Ok()
+                                .header(
+                                    "x-head",
+                                    HeaderValue::from_static("dummy value!"),
+                                )
+                                .body(body),
+                        )
+                    }
                })
                .tcp()
        })?
--- a/actix-http/examples/echo2.rs
+++ b/actix-http/examples/echo2.rs
@ -4,7 +4,7 @@ use actix_http::http::HeaderValue;
 use actix_http::{Error, HttpService, Request, Response};
 use actix_server::Server;
 use bytes::BytesMut;
-use futures_util::StreamExt;
+use futures::StreamExt;
 use log::info;

 async fn handle_request(mut req: Request) -> Result<Response, Error> {
--- a/actix-http/examples/hello-world.rs
+++ b/actix-http/examples/hello-world.rs
@ -2,7 +2,7 @@ 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;

--- a/actix-http/src/body.rs
+++ b/actix-http/src/body.rs
@ -5,8 +5,7 @@ use std::{fmt, mem};

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

 use crate::error::Error;

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

@ -24,7 +24,8 @@ impl BodySize {
        match self {
            BodySize::None
            | BodySize::Empty
-            | BodySize::Sized(0) => true,
+            | BodySize::Sized(0)
+            | BodySize::Sized64(0) => true,
            _ => false,
        }
    }
@ -34,46 +35,33 @@ 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, cx: &mut Context<'_>) -> Poll<Option<Result<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>>> {
+    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
        Poll::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, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+        self.as_mut().poll_next(cx)
    }
 }

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

 impl ResponseBody<Body> {
@ -109,13 +97,10 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
        }
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        match self.project() {
-            ResponseBodyProj::Body(body) => body.poll_next(cx),
-            ResponseBodyProj::Other(body) => body.poll_next(cx),
+    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+        match self {
+            ResponseBody::Body(ref mut body) => body.poll_next(cx),
+            ResponseBody::Other(ref mut body) => body.poll_next(cx),
        }
    }
 }
@ -123,18 +108,19 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
 impl<B: MessageBody> Stream for ResponseBody<B> {
    type Item = Result<Bytes, Error>;

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

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

 impl Body {
@ -154,7 +140,7 @@ impl Body {
    }

    /// 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))
    }
 }
@ -164,27 +150,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(),
        }
    }

-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        match self.project() {
-            BodyProj::None => Poll::Ready(None),
-            BodyProj::Empty => Poll::Ready(None),
-            BodyProj::Bytes(ref mut bin) => {
+    fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+        match self {
+            Body::None => Poll::Ready(None),
+            Body::Empty => Poll::Ready(None),
+            Body::Bytes(ref mut bin) => {
                let len = bin.len();
                if len == 0 {
                    Poll::Ready(None)
                } else {
-                    Poll::Ready(Some(Ok(mem::take(bin))))
+                    Poll::Ready(Some(Ok(mem::replace(bin, Bytes::new()))))
                }
            }
-            BodyProj::Message(ref mut body) => Pin::new(body.as_mut()).poll_next(cx),
+            Body::Message(ref mut body) => body.poll_next(cx),
        }
    }
 }
@ -270,7 +253,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 = Result<Bytes, Error>> + 'static,
 {
    fn from(s: SizedStream<S>) -> Body {
        Body::from_message(s)
@ -279,7 +262,7 @@ where

 impl<S, E> From<BodyStream<S, E>> for Body
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
+    S: Stream<Item = Result<Bytes, E>> + 'static,
    E: Into<Error> + 'static,
 {
    fn from(s: BodyStream<S, E>) -> Body {
@ -289,88 +272,87 @@ 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, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()))))
+            Poll::Ready(Some(Ok(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, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
-            Poll::Ready(Some(Ok(mem::take(self.get_mut()).freeze())))
+            Poll::Ready(Some(Ok(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, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
            Poll::Ready(Some(Ok(Bytes::from_static(
-                mem::take(self.get_mut()).as_ref(),
+                mem::replace(self, "").as_ref(),
            ))))
        }
    }
 }

+impl MessageBody for &'static [u8] {
+    fn size(&self) -> BodySize {
+        BodySize::Sized(self.len())
+    }
+
+    fn poll_next(&mut self, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.is_empty() {
+            Poll::Ready(None)
+        } else {
+            Poll::Ready(Some(Ok(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, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
-            Poll::Ready(Some(Ok(Bytes::from(mem::take(self.get_mut())))))
+            Poll::Ready(Some(Ok(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, _: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
        if self.is_empty() {
            Poll::Ready(None)
        } else {
            Poll::Ready(Some(Ok(Bytes::from(
-                mem::take(self.get_mut()).into_bytes(),
+                mem::replace(self, String::new()).into_bytes(),
            ))))
        }
    }
@ -379,7 +361,7 @@ 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> {
+pub struct BodyStream<S, E> {
    #[pin]
    stream: S,
    _t: PhantomData<E>,
@ -387,7 +369,7 @@ pub struct BodyStream<S: Unpin, E> {

 impl<S, E> BodyStream<S, E>
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    S: Stream<Item = Result<Bytes, E>>,
    E: Into<Error>,
 {
    pub fn new(stream: S) -> Self {
@ -400,37 +382,26 @@ where

 impl<S, E> MessageBody for BodyStream<S, E>
 where
-    S: Stream<Item = Result<Bytes, E>> + Unpin,
+    S: Stream<Item = Result<Bytes, 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, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+        unsafe { Pin::new_unchecked(self) }
+            .project()
+            .stream
+            .poll_next(cx)
+            .map(|res| res.map(|res| res.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,
@ -438,7 +409,7 @@ pub struct SizedStream<S: Unpin> {

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

 impl<S> MessageBody for SizedStream<S>
 where
-    S: Stream<Item = Result<Bytes, Error>> + Unpin,
+    S: Stream<Item = Result<Bytes, 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, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
+        unsafe { Pin::new_unchecked(self) }
+            .project()
+            .stream
+            .poll_next(cx)
    }
 }

 #[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] {
@ -506,10 +463,7 @@ mod tests {

        assert_eq!("test".size(), BodySize::Sized(4));
        assert_eq!(
-            poll_fn(|cx| Pin::new(&mut "test").poll_next(cx))
-                .await
-                .unwrap()
-                .ok(),
+            poll_fn(|cx| "test".poll_next(cx)).await.unwrap().ok(),
            Some(Bytes::from("test"))
        );
    }
@ -523,12 +477,13 @@ 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(),
+            poll_fn(|cx| (&b"test"[..]).poll_next(cx))
+                .await
+                .unwrap()
+                .ok(),
            Some(Bytes::from("test"))
        );
    }
@ -537,12 +492,10 @@ mod tests {
    async 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))
+            poll_fn(|cx| Vec::from("test").poll_next(cx))
                .await
                .unwrap()
                .ok(),
@ -552,44 +505,41 @@ mod tests {

    #[actix_rt::test]
    async fn test_bytes() {
-        let b = Bytes::from("test");
+        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(),
+            poll_fn(|cx| b.poll_next(cx)).await.unwrap().ok(),
            Some(Bytes::from("test"))
        );
    }

    #[actix_rt::test]
    async fn test_bytes_mut() {
-        let b = BytesMut::from("test");
+        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(),
+            poll_fn(|cx| b.poll_next(cx)).await.unwrap().ok(),
            Some(Bytes::from("test"))
        );
    }

    #[actix_rt::test]
    async fn test_string() {
-        let b = "test".to_owned();
+        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(),
+            poll_fn(|cx| b.poll_next(cx)).await.unwrap().ok(),
            Some(Bytes::from("test"))
        );
    }
@ -597,17 +547,14 @@ mod tests {
    #[actix_rt::test]
    async fn test_unit() {
        assert_eq!(().size(), BodySize::Empty);
-        assert!(poll_fn(|cx| Pin::new(&mut ()).poll_next(cx))
-            .await
-            .is_none());
+        assert!(poll_fn(|cx| ().poll_next(cx)).await.is_none());
    }

    #[actix_rt::test]
    async fn test_box() {
-        let val = Box::new(());
-        pin_mut!(val);
+        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!(poll_fn(|cx| val.poll_next(cx)).await.is_none());
    }

    #[actix_rt::test]
@ -642,97 +589,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/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,12 @@
-use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use std::{fmt, io, mem, time};

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

 use crate::body::MessageBody;
 use crate::h1::ClientCodec;
@ -205,7 +204,7 @@ where
    }
 }

-#[pin_project(project = EitherIoProj)]
+#[pin_project]
 pub enum EitherIo<A, B> {
    A(#[pin] A),
    B(#[pin] B),
@ -216,14 +215,16 @@ 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() {
-            EitherIoProj::A(val) => val.poll_read(cx, buf),
-            EitherIoProj::B(val) => val.poll_read(cx, buf),
+            EitherIo::A(val) => val.poll_read(cx, buf),
+            EitherIo::B(val) => val.poll_read(cx, buf),
        }
    }

@ -243,34 +244,41 @@ 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() {
-            EitherIoProj::A(val) => val.poll_write(cx, buf),
-            EitherIoProj::B(val) => val.poll_write(cx, buf),
+            EitherIo::A(val) => val.poll_write(cx, buf),
+            EitherIo::B(val) => val.poll_write(cx, buf),
        }
    }

+    #[project]
    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        #[project]
        match self.project() {
-            EitherIoProj::A(val) => val.poll_flush(cx),
-            EitherIoProj::B(val) => val.poll_flush(cx),
+            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() {
-            EitherIoProj::A(val) => val.poll_shutdown(cx),
-            EitherIoProj::B(val) => val.poll_shutdown(cx),
+            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<'_>,
@ -279,9 +287,10 @@ where
    where
        Self: Sized,
    {
+        #[project]
        match self.project() {
-            EitherIoProj::A(val) => val.poll_write_buf(cx, buf),
-            EitherIoProj::B(val) => val.poll_write_buf(cx, buf),
+            EitherIo::A(val) => val.poll_write_buf(cx, buf),
+            EitherIo::B(val) => val.poll_write_buf(cx, buf),
        }
    }
 }
--- a/actix-http/src/client/connector.rs
+++ b/actix-http/src/client/connector.rs
@ -11,7 +11,6 @@ use actix_service::{apply_fn, Service};
 use actix_utils::timeout::{TimeoutError, TimeoutService};
 use http::Uri;

-use super::config::ConnectorConfig;
 use super::connection::Connection;
 use super::error::ConnectError;
 use super::pool::{ConnectionPool, Protocol};
@ -49,7 +48,11 @@ 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>,
@ -68,47 +71,42 @@ impl Connector<(), ()> {
            > + Clone,
        TcpStream,
    > {
+        let ssl = {
+            #[cfg(feature = "openssl")]
+            {
+                use actix_connect::ssl::openssl::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 = "openssl"), feature = "rustls"))]
+            {
+                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(&actix_tls::rustls::TLS_SERVER_ROOTS);
+                SslConnector::Rustls(Arc::new(config))
+            }
+            #[cfg(not(any(feature = "openssl", feature = "rustls")))]
+            {}
+        };
+
        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> {
@ -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,
        }
@ -144,7 +146,7 @@ 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
    }

@ -161,44 +163,12 @@ where
        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
    }

@ -246,7 +216,7 @@ where
        #[cfg(not(any(feature = "openssl", feature = "rustls")))]
        {
            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,7 +231,10 @@ where
            connect_impl::InnerConnector {
                tcp_pool: ConnectionPool::new(
                    connector,
-                    self.config.no_disconnect_timeout(),
+                    self.conn_lifetime,
+                    self.conn_keep_alive,
+                    None,
+                    self.limit,
                ),
            }
        }
@ -275,7 +248,7 @@ where
            use actix_service::{boxed::service, pipeline};

            let ssl_service = TimeoutService::new(
-                self.config.timeout,
+                self.timeout,
                pipeline(
                    apply_fn(self.connector.clone(), |msg: Connect, srv| {
                        srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
@ -328,7 +301,7 @@ where
            });

            let tcp_service = TimeoutService::new(
-                self.config.timeout,
+                self.timeout,
                apply_fn(self.connector, |msg: Connect, srv| {
                    srv.call(TcpConnect::new(msg.uri).set_addr(msg.addr))
                })
@ -343,9 +316,18 @@ 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),
            }
        }
    }
--- a/actix-http/src/client/error.rs
+++ b/actix-http/src/client/error.rs
@ -39,7 +39,7 @@ pub enum ConnectError {
    H2(h2::Error),

    /// Connecting took too long
-    #[display(fmt = "Timeout while establishing connection")]
+    #[display(fmt = "Timeout out while establishing connection")]
    Timeout,

    /// Connector has been disconnected
@ -48,22 +48,20 @@ 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),
        }
    }
@ -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 {
@ -110,7 +106,7 @@ pub enum SendRequestError {
    #[display(fmt = "{}", _0)]
    H2(h2::Error),
    /// Response took too long
-    #[display(fmt = "Timeout while waiting for response")]
+    #[display(fmt = "Timeout out while waiting for response")]
    Timeout,
    /// Tunnels are not supported for http2 connection
    #[display(fmt = "Tunnels are not supported for http2 connection")]
@ -119,8 +115,6 @@ 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 {
@ -145,8 +139,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
@ -8,7 +8,7 @@ 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 futures_util::{SinkExt, StreamExt};

 use crate::error::PayloadError;
 use crate::h1;
@ -120,7 +120,7 @@ where

 /// send request body to the peer
 pub(crate) async fn send_body<I, B>(
-    body: B,
+    mut body: B,
    framed: &mut Framed<I, h1::ClientCodec>,
 ) -> Result<(), SendRequestError>
 where
@ -128,10 +128,9 @@ where
    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 {
+            match poll_fn(|cx| body.poll_next(cx)).await {
                Some(result) => {
                    framed.write(h1::Message::Chunk(Some(result?)))?;
                }
--- a/actix-http/src/client/h2proto.rs
+++ b/actix-http/src/client/h2proto.rs
@ -1,15 +1,10 @@
 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 h2::{client::SendRequest, SendStream};
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};

@ -18,7 +13,6 @@ 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;
@ -64,6 +58,10 @@ where
            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.
@ -125,14 +123,13 @@ where
 }

 async fn send_body<B: MessageBody>(
-    body: B,
+    mut 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 {
+            match poll_fn(|cx| body.poll_next(cx)).await {
                Some(Ok(b)) => {
                    send.reserve_capacity(b.len());
                    buf = Some(b);
@ -186,18 +183,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
@ -2,7 +2,7 @@ use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::future::Future;
 use std::pin::Pin;
-use std::rc::{Rc, Weak};
+use std::rc::Rc;
 use std::task::{Context, Poll};
 use std::time::{Duration, Instant};

@ -13,16 +13,13 @@ 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 h2::client::{handshake, Connection, SendRequest};
 use http::uri::Authority;
 use indexmap::IndexSet;
-use pin_project::pin_project;
 use slab::Slab;

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

 #[derive(Clone, Copy, PartialEq)]
@ -52,26 +49,26 @@ where
    T: Service<Request = Connect, Response = (Io, Protocol), Error = ConnectError>
        + 'static,
 {
-    pub(crate) fn new(connector: T, config: ConnectorConfig) -> Self {
-        let connector_rc = Rc::new(RefCell::new(connector));
-        let inner_rc = Rc::new(RefCell::new(Inner {
-            config,
-            acquired: 0,
-            waiters: Slab::new(),
-            waiters_queue: IndexSet::new(),
-            available: FxHashMap::default(),
-            waker: LocalWaker::new(),
-        }));
-
-        // start support future
-        actix_rt::spawn(ConnectorPoolSupport {
-            connector: connector_rc.clone(),
-            inner: Rc::downgrade(&inner_rc),
-        });
-
+    pub(crate) fn new(
+        connector: T,
+        conn_lifetime: Duration,
+        conn_keep_alive: Duration,
+        disconnect_timeout: Option<Duration>,
+        limit: usize,
+    ) -> Self {
        ConnectionPool(
-            connector_rc,
-            inner_rc,
+            Rc::new(RefCell::new(connector)),
+            Rc::new(RefCell::new(Inner {
+                conn_lifetime,
+                conn_keep_alive,
+                disconnect_timeout,
+                limit,
+                acquired: 0,
+                waiters: Slab::new(),
+                waiters_queue: IndexSet::new(),
+                available: FxHashMap::default(),
+                waker: LocalWaker::new(),
+            })),
        )
    }
 }
@ -101,6 +98,12 @@ where
    }

    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();

@ -108,7 +111,7 @@ where
            let key = if let Some(authority) = req.uri.authority() {
                authority.clone().into()
            } else {
-                return Err(ConnectError::Unresolved);
+                return Err(ConnectError::Unresolverd);
            };

            // acquire connection
@ -125,8 +128,6 @@ where
                    // 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 {
@ -136,7 +137,7 @@ where
                            Some(guard.consume()),
                        ))
                    } else {
-                        let (snd, connection) = handshake(io, &config).await?;
+                        let (snd, connection) = handshake(io).await?;
                        actix_rt::spawn(connection.map(|_| ()));
                        Ok(IoConnection::new(
                            ConnectionType::H2(snd),
@ -198,7 +199,7 @@ where
        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();
        }
    }
 }
@ -235,7 +236,7 @@ where
        if let Some(i) = self.inner.take() {
            let mut inner = i.as_ref().borrow_mut();
            inner.release();
-            inner.check_availability();
+            inner.check_availibility();
        }
    }
 }
@ -253,7 +254,10 @@ 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>>>,
    waiters: Slab<
@ -306,7 +310,7 @@ where

    fn acquire(&mut self, key: &Key, cx: &mut Context<'_>) -> 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;
        }

@ -318,10 +322,10 @@ 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))
                        }
@ -333,7 +337,7 @@ where
                        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 {
+                                if let Some(timeout) = self.disconnect_timeout {
                                    if let ConnectionType::H1(io) = io {
                                        actix_rt::spawn(CloseConnection::new(
                                            io, timeout,
@ -362,21 +366,21 @@ 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))
            }
        }
-        self.check_availability();
+        self.check_availibility();
    }

-    fn check_availability(&self) {
-        if !self.waiters_queue.is_empty() && self.acquired < self.config.limit {
+    fn check_availibility(&self) {
+        if !self.waiters_queue.is_empty() && self.acquired < self.limit {
            self.waker.wake();
        }
    }
@ -418,13 +422,12 @@ where
    }
 }

-#[pin_project]
 struct ConnectorPoolSupport<T, Io>
 where
    Io: AsyncRead + AsyncWrite + Unpin + 'static,
 {
    connector: T,
-    inner: Weak<RefCell<Inner<Io>>>,
+    inner: Rc<RefCell<Inner<Io>>>,
 }

 impl<T, Io> Future for ConnectorPoolSupport<T, Io>
@ -436,66 +439,59 @@ where
    type Output = ();

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
+        let this = unsafe { self.get_unchecked_mut() };

-        if let Some(this_inner) = this.inner.upgrade() {
-            let mut inner = this_inner.as_ref().borrow_mut();
-            inner.waker.register(cx.waker());
+        let mut inner = this.inner.as_ref().borrow_mut();
+        inner.waker.register(cx.waker());

-            // check waiters
-            loop {
-                let (key, token) = {
-                    if let Some((key, token)) = inner.waiters_queue.get_index(0) {
-                        (key.clone(), *token)
-                    } else {
-                        break;
-                    }
-                };
-                if inner.waiters.get(token).unwrap().is_none() {
-                    continue;
+        // check waiters
+        loop {
+            let (key, token) = {
+                if let Some((key, token)) = inner.waiters_queue.get_index(0) {
+                    (key.clone(), *token)
+                } else {
+                    break;
                }
-
-                match inner.acquire(&key, cx) {
-                    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()))),
-                        ))) {
-                            let (io, created) = conn.unwrap().into_inner();
-                            inner.release_conn(&key, io, created);
-                        }
-                    }
-                    Acquire::Available => {
-                        let (connect, tx) =
-                            inner.waiters.get_mut(token).unwrap().take().unwrap();
-                        OpenWaitingConnection::spawn(
-                            key.clone(),
-                            tx,
-                            this_inner.clone(),
-                            this.connector.call(connect),
-                            inner.config.clone(),
-                        );
-                    }
-                }
-                let _ = inner.waiters_queue.swap_remove_index(0);
+            };
+            if inner.waiters.get(token).unwrap().is_none() {
+                continue;
            }

-            Poll::Pending
-        } else {
-            Poll::Ready(())
+            match inner.acquire(&key, cx) {
+                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()))),
+                    ))) {
+                        let (io, created) = conn.unwrap().into_inner();
+                        inner.release_conn(&key, io, created);
+                    }
+                }
+                Acquire::Available => {
+                    let (connect, tx) =
+                        inner.waiters.get_mut(token).unwrap().take().unwrap();
+                    OpenWaitingConnection::spawn(
+                        key.clone(),
+                        tx,
+                        this.inner.clone(),
+                        this.connector.call(connect),
+                    );
+                }
+            }
+            let _ = inner.waiters_queue.swap_remove_index(0);
        }
+
+        Poll::Pending
    }
 }

-#[pin_project::pin_project(PinnedDrop)]
 struct OpenWaitingConnection<F, Io>
 where
    Io: AsyncRead + AsyncWrite + Unpin + 'static,
 {
-    #[pin]
    fut: F,
    key: Key,
    h2: Option<
@ -506,7 +502,6 @@ where
    >,
    rx: Option<oneshot::Sender<Result<IoConnection<Io>, ConnectError>>>,
    inner: Option<Rc<RefCell<Inner<Io>>>>,
-    config: ConnectorConfig,
 }

 impl<F, Io> OpenWaitingConnection<F, Io>
@ -519,7 +514,6 @@ where
        rx: oneshot::Sender<Result<IoConnection<Io>, ConnectError>>,
        inner: Rc<RefCell<Inner<Io>>>,
        fut: F,
-        config: ConnectorConfig,
    ) {
        actix_rt::spawn(OpenWaitingConnection {
            key,
@ -527,21 +521,19 @@ where
            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,
 {
-    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();
        }
    }
 }
@ -553,8 +545,8 @@ where
 {
    type Output = ();

-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = unsafe { self.get_unchecked_mut() };

        if let Some(ref mut h2) = this.h2 {
            return match Pin::new(h2).poll(cx) {
@ -579,7 +571,7 @@ where
            };
        }

-        match this.fut.poll(cx) {
+        match unsafe { Pin::new_unchecked(&mut this.fut) }.poll(cx) {
            Poll::Ready(Err(err)) => {
                let _ = this.inner.take();
                if let Some(rx) = this.rx.take() {
@ -597,8 +589,8 @@ where
                    )));
                    Poll::Ready(())
                } else {
-                    *this.h2 = Some(handshake(io, this.config).boxed_local());
-                    self.poll(cx)
+                    this.h2 = Some(handshake(io).boxed_local());
+                    unsafe { Pin::new_unchecked(this) }.poll(cx)
                }
            }
            Poll::Pending => Poll::Pending,
--- a/actix-http/src/cloneable.rs
+++ b/actix-http/src/cloneable.rs
@ -1,4 +1,4 @@
-use std::cell::RefCell;
+use std::cell::UnsafeCell;
 use std::rc::Rc;
 use std::task::{Context, Poll};

@ -6,15 +6,11 @@ use actix_service::Service;

 #[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: Service>(Rc<UnsafeCell<T>>);

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

@ -31,10 +27,10 @@ impl<T: Service> Service for CloneableService<T> {
    type Future = T::Future;

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

    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,4 +1,4 @@
-use std::cell::Cell;
+use std::cell::UnsafeCell;
 use std::fmt::Write;
 use std::rc::Rc;
 use std::time::Duration;
@ -7,7 +7,7 @@ use std::{fmt, net};
 use actix_rt::time::{delay_for, delay_until, Delay, Instant};
 use bytes::BytesMut;
 use futures_util::{future, FutureExt};
-use time::OffsetDateTime;
+use time;

 // "Sun, 06 Nov 1994 08:49:37 GMT".len()
 const DATE_VALUE_LENGTH: usize = 29;
@ -114,7 +114,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
    }
@ -211,12 +211,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 +228,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,7 +255,7 @@ 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
@ -274,12 +269,12 @@ impl DateService {

    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 })
    }
 }

@ -287,16 +282,6 @@ impl DateService {
 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());
-    }
-
    #[test]
    fn test_date_len() {
        assert_eq!(DATE_VALUE_LENGTH, "Sun, 06 Nov 1994 08:49:37 GMT".len());
--- a/actix-http/src/cookie/builder.rs
+++ b/actix-http/src/cookie/builder.rs
@ -0,0 +1,250 @@
+use std::borrow::Cow;
+
+use chrono::Duration;
+use time::Tm;
+
+use super::{Cookie, SameSite};
+
+/// Structure that follows the builder pattern for building `Cookie` structs.
+///
+/// To construct a cookie:
+///
+///   1. Call [`Cookie::build`](struct.Cookie.html#method.build) to start building.
+///   2. Use any of the builder methods to set fields in the cookie.
+///   3. Call [finish](#method.finish) to retrieve the built cookie.
+///
+/// # Example
+///
+/// ```rust
+/// use actix_http::cookie::Cookie;
+///
+/// let cookie: Cookie = Cookie::build("name", "value")
+///     .domain("www.rust-lang.org")
+///     .path("/")
+///     .secure(true)
+///     .http_only(true)
+///     .max_age(84600)
+///     .finish();
+/// ```
+#[derive(Debug, Clone)]
+pub struct CookieBuilder {
+    /// The cookie being built.
+    cookie: Cookie<'static>,
+}
+
+impl CookieBuilder {
+    /// Creates a new `CookieBuilder` instance from the given name and value.
+    ///
+    /// This method is typically called indirectly via
+    /// [Cookie::build](struct.Cookie.html#method.build).
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar").finish();
+    /// assert_eq!(c.name_value(), ("foo", "bar"));
+    /// ```
+    pub fn new<N, V>(name: N, value: V) -> CookieBuilder
+    where
+        N: Into<Cow<'static, str>>,
+        V: Into<Cow<'static, str>>,
+    {
+        CookieBuilder {
+            cookie: Cookie::new(name, value),
+        }
+    }
+
+    /// Sets the `expires` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .expires(time::now())
+    ///     .finish();
+    ///
+    /// assert!(c.expires().is_some());
+    /// ```
+    #[inline]
+    pub fn expires(mut self, when: Tm) -> CookieBuilder {
+        self.cookie.set_expires(when);
+        self
+    }
+
+    /// Sets the `max_age` field in seconds in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .max_age(1800)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
+    /// ```
+    #[inline]
+    pub fn max_age(self, seconds: i64) -> CookieBuilder {
+        self.max_age_time(Duration::seconds(seconds))
+    }
+
+    /// Sets the `max_age` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .max_age_time(time::Duration::minutes(30))
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(time::Duration::seconds(30 * 60)));
+    /// ```
+    #[inline]
+    pub fn max_age_time(mut self, value: Duration) -> CookieBuilder {
+        self.cookie.set_max_age(value);
+        self
+    }
+
+    /// Sets the `domain` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .domain("www.rust-lang.org")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.domain(), Some("www.rust-lang.org"));
+    /// ```
+    pub fn domain<D: Into<Cow<'static, str>>>(mut self, value: D) -> CookieBuilder {
+        self.cookie.set_domain(value);
+        self
+    }
+
+    /// Sets the `path` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .path("/")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.path(), Some("/"));
+    /// ```
+    pub fn path<P: Into<Cow<'static, str>>>(mut self, path: P) -> CookieBuilder {
+        self.cookie.set_path(path);
+        self
+    }
+
+    /// Sets the `secure` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .secure(true)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.secure(), Some(true));
+    /// ```
+    #[inline]
+    pub fn secure(mut self, value: bool) -> CookieBuilder {
+        self.cookie.set_secure(value);
+        self
+    }
+
+    /// Sets the `http_only` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .http_only(true)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.http_only(), Some(true));
+    /// ```
+    #[inline]
+    pub fn http_only(mut self, value: bool) -> CookieBuilder {
+        self.cookie.set_http_only(value);
+        self
+    }
+
+    /// Sets the `same_site` field in the cookie being built.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{Cookie, SameSite};
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .same_site(SameSite::Strict)
+    ///     .finish();
+    ///
+    /// assert_eq!(c.same_site(), Some(SameSite::Strict));
+    /// ```
+    #[inline]
+    pub fn same_site(mut self, value: SameSite) -> CookieBuilder {
+        self.cookie.set_same_site(value);
+        self
+    }
+
+    /// Makes the cookie being built 'permanent' by extending its expiration and
+    /// max age 20 years into the future.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    /// use chrono::Duration;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .permanent()
+    ///     .finish();
+    ///
+    /// assert_eq!(c.max_age(), Some(Duration::days(365 * 20)));
+    /// # assert!(c.expires().is_some());
+    /// ```
+    #[inline]
+    pub fn permanent(mut self) -> CookieBuilder {
+        self.cookie.make_permanent();
+        self
+    }
+
+    /// Finishes building and returns the built `Cookie`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Cookie;
+    ///
+    /// let c = Cookie::build("foo", "bar")
+    ///     .domain("crates.io")
+    ///     .path("/")
+    ///     .finish();
+    ///
+    /// assert_eq!(c.name_value(), ("foo", "bar"));
+    /// assert_eq!(c.domain(), Some("crates.io"));
+    /// assert_eq!(c.path(), Some("/"));
+    /// ```
+    #[inline]
+    pub fn finish(self) -> Cookie<'static> {
+        self.cookie
+    }
+}
--- a/actix-http/src/cookie/delta.rs
+++ b/actix-http/src/cookie/delta.rs
@ -0,0 +1,71 @@
+use std::borrow::Borrow;
+use std::hash::{Hash, Hasher};
+use std::ops::{Deref, DerefMut};
+
+use super::Cookie;
+
+/// A `DeltaCookie` is a helper structure used in a cookie jar. It wraps a
+/// `Cookie` so that it can be hashed and compared purely by name. It further
+/// records whether the wrapped cookie is a "removal" cookie, that is, a cookie
+/// that when sent to the client removes the named cookie on the client's
+/// machine.
+#[derive(Clone, Debug)]
+pub struct DeltaCookie {
+    pub cookie: Cookie<'static>,
+    pub removed: bool,
+}
+
+impl DeltaCookie {
+    /// Create a new `DeltaCookie` that is being added to a jar.
+    #[inline]
+    pub fn added(cookie: Cookie<'static>) -> DeltaCookie {
+        DeltaCookie {
+            cookie,
+            removed: false,
+        }
+    }
+
+    /// Create a new `DeltaCookie` that is being removed from a jar. The
+    /// `cookie` should be a "removal" cookie.
+    #[inline]
+    pub fn removed(cookie: Cookie<'static>) -> DeltaCookie {
+        DeltaCookie {
+            cookie,
+            removed: true,
+        }
+    }
+}
+
+impl Deref for DeltaCookie {
+    type Target = Cookie<'static>;
+
+    fn deref(&self) -> &Cookie<'static> {
+        &self.cookie
+    }
+}
+
+impl DerefMut for DeltaCookie {
+    fn deref_mut(&mut self) -> &mut Cookie<'static> {
+        &mut self.cookie
+    }
+}
+
+impl PartialEq for DeltaCookie {
+    fn eq(&self, other: &DeltaCookie) -> bool {
+        self.name() == other.name()
+    }
+}
+
+impl Eq for DeltaCookie {}
+
+impl Hash for DeltaCookie {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name().hash(state);
+    }
+}
+
+impl Borrow<str> for DeltaCookie {
+    fn borrow(&self) -> &str {
+        self.name()
+    }
+}
--- a/actix-http/src/cookie/draft.rs
+++ b/actix-http/src/cookie/draft.rs
@ -0,0 +1,98 @@
+//! This module contains types that represent cookie properties that are not yet
+//! standardized. That is, _draft_ features.
+
+use std::fmt;
+
+/// The `SameSite` cookie attribute.
+///
+/// A cookie with a `SameSite` attribute is imposed restrictions on when it is
+/// sent to the origin server in a cross-site request. If the `SameSite`
+/// attribute is "Strict", then the cookie is never sent in cross-site requests.
+/// If the `SameSite` attribute is "Lax", the cookie is only sent in cross-site
+/// requests with "safe" HTTP methods, i.e, `GET`, `HEAD`, `OPTIONS`, `TRACE`.
+/// If the `SameSite` attribute is not present (made explicit via the
+/// `SameSite::None` variant), then the cookie will be sent as normal.
+///
+/// **Note:** This cookie attribute is an HTTP draft! Its meaning and definition
+/// are subject to change.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SameSite {
+    /// The "Strict" `SameSite` attribute.
+    Strict,
+    /// The "Lax" `SameSite` attribute.
+    Lax,
+    /// No `SameSite` attribute.
+    None,
+}
+
+impl SameSite {
+    /// Returns `true` if `self` is `SameSite::Strict` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::SameSite;
+    ///
+    /// let strict = SameSite::Strict;
+    /// assert!(strict.is_strict());
+    /// assert!(!strict.is_lax());
+    /// assert!(!strict.is_none());
+    /// ```
+    #[inline]
+    pub fn is_strict(self) -> bool {
+        match self {
+            SameSite::Strict => true,
+            SameSite::Lax | SameSite::None => false,
+        }
+    }
+
+    /// Returns `true` if `self` is `SameSite::Lax` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::SameSite;
+    ///
+    /// let lax = SameSite::Lax;
+    /// assert!(lax.is_lax());
+    /// assert!(!lax.is_strict());
+    /// assert!(!lax.is_none());
+    /// ```
+    #[inline]
+    pub fn is_lax(self) -> bool {
+        match self {
+            SameSite::Lax => true,
+            SameSite::Strict | SameSite::None => false,
+        }
+    }
+
+    /// Returns `true` if `self` is `SameSite::None` and `false` otherwise.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::SameSite;
+    ///
+    /// let none = SameSite::None;
+    /// assert!(none.is_none());
+    /// assert!(!none.is_lax());
+    /// assert!(!none.is_strict());
+    /// ```
+    #[inline]
+    pub fn is_none(self) -> bool {
+        match self {
+            SameSite::None => true,
+            SameSite::Lax | SameSite::Strict => false,
+        }
+    }
+}
+
+impl fmt::Display for SameSite {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            SameSite::Strict => write!(f, "Strict"),
+            SameSite::Lax => write!(f, "Lax"),
+            SameSite::None => Ok(()),
+        }
+    }
+}
--- a/actix-http/src/cookie/jar.rs
+++ b/actix-http/src/cookie/jar.rs
@ -0,0 +1,651 @@
+use std::collections::HashSet;
+use std::mem::replace;
+
+use chrono::Duration;
+
+use super::delta::DeltaCookie;
+use super::Cookie;
+
+#[cfg(feature = "secure-cookies")]
+use super::secure::{Key, PrivateJar, SignedJar};
+
+/// A collection of cookies that tracks its modifications.
+///
+/// A `CookieJar` provides storage for any number of cookies. Any changes made
+/// to the jar are tracked; the changes can be retrieved via the
+/// [delta](#method.delta) method which returns an interator over the changes.
+///
+/// # Usage
+///
+/// A jar's life begins via [new](#method.new) and calls to
+/// [`add_original`](#method.add_original):
+///
+/// ```rust
+/// use actix_http::cookie::{Cookie, CookieJar};
+///
+/// let mut jar = CookieJar::new();
+/// jar.add_original(Cookie::new("name", "value"));
+/// jar.add_original(Cookie::new("second", "another"));
+/// ```
+///
+/// Cookies can be added via [add](#method.add) and removed via
+/// [remove](#method.remove). Finally, cookies can be looked up via
+/// [get](#method.get):
+///
+/// ```rust
+/// # use actix_http::cookie::{Cookie, CookieJar};
+/// let mut jar = CookieJar::new();
+/// jar.add(Cookie::new("a", "one"));
+/// jar.add(Cookie::new("b", "two"));
+///
+/// assert_eq!(jar.get("a").map(|c| c.value()), Some("one"));
+/// assert_eq!(jar.get("b").map(|c| c.value()), Some("two"));
+///
+/// jar.remove(Cookie::named("b"));
+/// assert!(jar.get("b").is_none());
+/// ```
+///
+/// # Deltas
+///
+/// A jar keeps track of any modifications made to it over time. The
+/// modifications are recorded as cookies. The modifications can be retrieved
+/// via [delta](#method.delta). Any new `Cookie` added to a jar via `add`
+/// results in the same `Cookie` appearing in the `delta`; cookies added via
+/// `add_original` do not count towards the delta. Any _original_ cookie that is
+/// removed from a jar results in a "removal" cookie appearing in the delta. A
+/// "removal" cookie is a cookie that a server sends so that the cookie is
+/// removed from the client's machine.
+///
+/// Deltas are typically used to create `Set-Cookie` headers corresponding to
+/// the changes made to a cookie jar over a period of time.
+///
+/// ```rust
+/// # use actix_http::cookie::{Cookie, CookieJar};
+/// let mut jar = CookieJar::new();
+///
+/// // original cookies don't affect the delta
+/// jar.add_original(Cookie::new("original", "value"));
+/// assert_eq!(jar.delta().count(), 0);
+///
+/// // new cookies result in an equivalent `Cookie` in the delta
+/// jar.add(Cookie::new("a", "one"));
+/// jar.add(Cookie::new("b", "two"));
+/// assert_eq!(jar.delta().count(), 2);
+///
+/// // removing an original cookie adds a "removal" cookie to the delta
+/// jar.remove(Cookie::named("original"));
+/// assert_eq!(jar.delta().count(), 3);
+///
+/// // removing a new cookie that was added removes that `Cookie` from the delta
+/// jar.remove(Cookie::named("a"));
+/// assert_eq!(jar.delta().count(), 2);
+/// ```
+#[derive(Default, Debug, Clone)]
+pub struct CookieJar {
+    original_cookies: HashSet<DeltaCookie>,
+    delta_cookies: HashSet<DeltaCookie>,
+}
+
+impl CookieJar {
+    /// Creates an empty cookie jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::CookieJar;
+    ///
+    /// let jar = CookieJar::new();
+    /// assert_eq!(jar.iter().count(), 0);
+    /// ```
+    pub fn new() -> CookieJar {
+        CookieJar::default()
+    }
+
+    /// Returns a reference to the `Cookie` inside this jar with the name
+    /// `name`. If no such cookie exists, returns `None`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// assert!(jar.get("name").is_none());
+    ///
+    /// jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// ```
+    pub fn get(&self, name: &str) -> Option<&Cookie<'static>> {
+        self.delta_cookies
+            .get(name)
+            .or_else(|| self.original_cookies.get(name))
+            .and_then(|c| if !c.removed { Some(&c.cookie) } else { None })
+    }
+
+    /// Adds an "original" `cookie` to this jar. If an original cookie with the
+    /// same name already exists, it is replaced with `cookie`. Cookies added
+    /// with `add` take precedence and are not replaced by this method.
+    ///
+    /// Adding an original cookie does not affect the [delta](#method.delta)
+    /// computation. This method is intended to be used to seed the cookie jar
+    /// with cookies received from a client's HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
+    /// assert_eq!(jar.iter().count(), 2);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, cookie: Cookie<'static>) {
+        self.original_cookies.replace(DeltaCookie::added(cookie));
+    }
+
+    /// Adds `cookie` to this jar. If a cookie with the same name already
+    /// exists, it is replaced with `cookie`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add(Cookie::new("name", "value"));
+    /// jar.add(Cookie::new("second", "two"));
+    ///
+    /// assert_eq!(jar.get("name").map(|c| c.value()), Some("value"));
+    /// assert_eq!(jar.get("second").map(|c| c.value()), Some("two"));
+    /// assert_eq!(jar.iter().count(), 2);
+    /// assert_eq!(jar.delta().count(), 2);
+    /// ```
+    pub fn add(&mut self, cookie: Cookie<'static>) {
+        self.delta_cookies.replace(DeltaCookie::added(cookie));
+    }
+
+    /// Removes `cookie` from this jar. If an _original_ cookie with the same
+    /// name as `cookie` is present in the jar, a _removal_ cookie will be
+    /// present in the `delta` computation. To properly generate the removal
+    /// cookie, `cookie` must contain the same `path` and `domain` as the cookie
+    /// that was initially set.
+    ///
+    /// A "removal" cookie is a cookie that has the same name as the original
+    /// cookie but has an empty value, a max-age of 0, and an expiration date
+    /// far in the past.
+    ///
+    /// # Example
+    ///
+    /// Removing an _original_ cookie results in a _removal_ cookie:
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    /// use chrono::Duration;
+    ///
+    /// let mut jar = CookieJar::new();
+    ///
+    /// // Assume this cookie originally had a path of "/" and domain of "a.b".
+    /// jar.add_original(Cookie::new("name", "value"));
+    ///
+    /// // If the path and domain were set, they must be provided to `remove`.
+    /// jar.remove(Cookie::build("name", "").path("/").domain("a.b").finish());
+    ///
+    /// // The delta will contain the removal cookie.
+    /// let delta: Vec<_> = jar.delta().collect();
+    /// assert_eq!(delta.len(), 1);
+    /// assert_eq!(delta[0].name(), "name");
+    /// assert_eq!(delta[0].max_age(), Some(Duration::seconds(0)));
+    /// ```
+    ///
+    /// Removing a new cookie does not result in a _removal_ cookie:
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    ///
+    /// jar.remove(Cookie::named("name"));
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn remove(&mut self, mut cookie: Cookie<'static>) {
+        if self.original_cookies.contains(cookie.name()) {
+            cookie.set_value("");
+            cookie.set_max_age(Duration::seconds(0));
+            cookie.set_expires(time::now() - Duration::days(365));
+            self.delta_cookies.replace(DeltaCookie::removed(cookie));
+        } else {
+            self.delta_cookies.remove(cookie.name());
+        }
+    }
+
+    /// Removes `cookie` from this jar completely. This method differs from
+    /// `remove` in that no delta cookie is created under any condition. Neither
+    /// the `delta` nor `iter` methods will return a cookie that is removed
+    /// using this method.
+    ///
+    /// # Example
+    ///
+    /// Removing an _original_ cookie; no _removal_ cookie is generated:
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    /// use chrono::Duration;
+    ///
+    /// let mut jar = CookieJar::new();
+    ///
+    /// // Add an original cookie and a new cookie.
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add(Cookie::new("key", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    /// assert_eq!(jar.iter().count(), 2);
+    ///
+    /// // Now force remove the original cookie.
+    /// jar.force_remove(Cookie::new("name", "value"));
+    /// assert_eq!(jar.delta().count(), 1);
+    /// assert_eq!(jar.iter().count(), 1);
+    ///
+    /// // Now force remove the new cookie.
+    /// jar.force_remove(Cookie::new("key", "value"));
+    /// assert_eq!(jar.delta().count(), 0);
+    /// assert_eq!(jar.iter().count(), 0);
+    /// ```
+    pub fn force_remove<'a>(&mut self, cookie: Cookie<'a>) {
+        self.original_cookies.remove(cookie.name());
+        self.delta_cookies.remove(cookie.name());
+    }
+
+    /// Removes all cookies from this cookie jar.
+    #[deprecated(
+        since = "0.7.0",
+        note = "calling this method may not remove \
+                all cookies since the path and domain are not specified; use \
+                `remove` instead"
+    )]
+    pub fn clear(&mut self) {
+        self.delta_cookies.clear();
+        for delta in replace(&mut self.original_cookies, HashSet::new()) {
+            self.remove(delta.cookie);
+        }
+    }
+
+    /// Returns an iterator over cookies that represent the changes to this jar
+    /// over time. These cookies can be rendered directly as `Set-Cookie` header
+    /// values to affect the changes made to this jar on the client.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// // Add new cookies.
+    /// jar.add(Cookie::new("new", "third"));
+    /// jar.add(Cookie::new("another", "fourth"));
+    /// jar.add(Cookie::new("yac", "fifth"));
+    ///
+    /// // Remove some cookies.
+    /// jar.remove(Cookie::named("name"));
+    /// jar.remove(Cookie::named("another"));
+    ///
+    /// // Delta contains two new cookies ("new", "yac") and a removal ("name").
+    /// assert_eq!(jar.delta().count(), 3);
+    /// ```
+    pub fn delta(&self) -> Delta<'_> {
+        Delta {
+            iter: self.delta_cookies.iter(),
+        }
+    }
+
+    /// Returns an iterator over all of the cookies present in this jar.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie};
+    ///
+    /// let mut jar = CookieJar::new();
+    ///
+    /// jar.add_original(Cookie::new("name", "value"));
+    /// jar.add_original(Cookie::new("second", "two"));
+    ///
+    /// jar.add(Cookie::new("new", "third"));
+    /// jar.add(Cookie::new("another", "fourth"));
+    /// jar.add(Cookie::new("yac", "fifth"));
+    ///
+    /// jar.remove(Cookie::named("name"));
+    /// jar.remove(Cookie::named("another"));
+    ///
+    /// // There are three cookies in the jar: "second", "new", and "yac".
+    /// # assert_eq!(jar.iter().count(), 3);
+    /// for cookie in jar.iter() {
+    ///     match cookie.name() {
+    ///         "second" => assert_eq!(cookie.value(), "two"),
+    ///         "new" => assert_eq!(cookie.value(), "third"),
+    ///         "yac" => assert_eq!(cookie.value(), "fifth"),
+    ///         _ => unreachable!("there are only three cookies in the jar")
+    ///     }
+    /// }
+    /// ```
+    pub fn iter(&self) -> Iter<'_> {
+        Iter {
+            delta_cookies: self
+                .delta_cookies
+                .iter()
+                .chain(self.original_cookies.difference(&self.delta_cookies)),
+        }
+    }
+
+    /// Returns a `PrivateJar` with `self` as its parent jar using the key `key`
+    /// to sign/encrypt and verify/decrypt cookies added/retrieved from the
+    /// child jar.
+    ///
+    /// Any modifications to the child jar will be reflected on the parent jar,
+    /// and any retrievals from the child jar will be made from the parent jar.
+    ///
+    /// This method is only available when the `secure` feature is enabled.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a private (signed + encrypted) cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.private(&key).add(Cookie::new("private", "text"));
+    ///
+    /// // The cookie's contents are encrypted.
+    /// assert_ne!(jar.get("private").unwrap().value(), "text");
+    ///
+    /// // They can be decrypted and verified through the child jar.
+    /// assert_eq!(jar.private(&key).get("private").unwrap().value(), "text");
+    ///
+    /// // A tampered with cookie does not validate but still exists.
+    /// let mut cookie = jar.get("private").unwrap().clone();
+    /// jar.add(Cookie::new("private", cookie.value().to_string() + "!"));
+    /// assert!(jar.private(&key).get("private").is_none());
+    /// assert!(jar.get("private").is_some());
+    /// ```
+    #[cfg(feature = "secure-cookies")]
+    pub fn private(&mut self, key: &Key) -> PrivateJar<'_> {
+        PrivateJar::new(self, key)
+    }
+
+    /// Returns a `SignedJar` with `self` as its parent jar using the key `key`
+    /// to sign/verify cookies added/retrieved from the child jar.
+    ///
+    /// Any modifications to the child jar will be reflected on the parent jar,
+    /// and any retrievals from the child jar will be made from the parent jar.
+    ///
+    /// This method is only available when the `secure` feature is enabled.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{Cookie, CookieJar, Key};
+    ///
+    /// // Generate a secure key.
+    /// let key = Key::generate();
+    ///
+    /// // Add a signed cookie.
+    /// let mut jar = CookieJar::new();
+    /// jar.signed(&key).add(Cookie::new("signed", "text"));
+    ///
+    /// // The cookie's contents are signed but still in plaintext.
+    /// assert_ne!(jar.get("signed").unwrap().value(), "text");
+    /// assert!(jar.get("signed").unwrap().value().contains("text"));
+    ///
+    /// // They can be verified through the child jar.
+    /// assert_eq!(jar.signed(&key).get("signed").unwrap().value(), "text");
+    ///
+    /// // A tampered with cookie does not validate but still exists.
+    /// let mut cookie = jar.get("signed").unwrap().clone();
+    /// jar.add(Cookie::new("signed", cookie.value().to_string() + "!"));
+    /// assert!(jar.signed(&key).get("signed").is_none());
+    /// assert!(jar.get("signed").is_some());
+    /// ```
+    #[cfg(feature = "secure-cookies")]
+    pub fn signed(&mut self, key: &Key) -> SignedJar<'_> {
+        SignedJar::new(self, key)
+    }
+}
+
+use std::collections::hash_set::Iter as HashSetIter;
+
+/// Iterator over the changes to a cookie jar.
+pub struct Delta<'a> {
+    iter: HashSetIter<'a, DeltaCookie>,
+}
+
+impl<'a> Iterator for Delta<'a> {
+    type Item = &'a Cookie<'static>;
+
+    fn next(&mut self) -> Option<&'a Cookie<'static>> {
+        self.iter.next().map(|c| &c.cookie)
+    }
+}
+
+use std::collections::hash_map::RandomState;
+use std::collections::hash_set::Difference;
+use std::iter::Chain;
+
+/// Iterator over all of the cookies in a jar.
+pub struct Iter<'a> {
+    delta_cookies:
+        Chain<HashSetIter<'a, DeltaCookie>, Difference<'a, DeltaCookie, RandomState>>,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = &'a Cookie<'static>;
+
+    fn next(&mut self) -> Option<&'a Cookie<'static>> {
+        for cookie in self.delta_cookies.by_ref() {
+            if !cookie.removed {
+                return Some(&*cookie);
+            }
+        }
+
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[cfg(feature = "secure-cookies")]
+    use super::Key;
+    use super::{Cookie, CookieJar};
+
+    #[test]
+    #[allow(deprecated)]
+    fn simple() {
+        let mut c = CookieJar::new();
+
+        c.add(Cookie::new("test", ""));
+        c.add(Cookie::new("test2", ""));
+        c.remove(Cookie::named("test"));
+
+        assert!(c.get("test").is_none());
+        assert!(c.get("test2").is_some());
+
+        c.add(Cookie::new("test3", ""));
+        c.clear();
+
+        assert!(c.get("test").is_none());
+        assert!(c.get("test2").is_none());
+        assert!(c.get("test3").is_none());
+    }
+
+    #[test]
+    fn jar_is_send() {
+        fn is_send<T: Send>(_: T) -> bool {
+            true
+        }
+
+        assert!(is_send(CookieJar::new()))
+    }
+
+    #[test]
+    #[cfg(feature = "secure-cookies")]
+    fn iter() {
+        let key = Key::generate();
+        let mut c = CookieJar::new();
+
+        c.add_original(Cookie::new("original", "original"));
+
+        c.add(Cookie::new("test", "test"));
+        c.add(Cookie::new("test2", "test2"));
+        c.add(Cookie::new("test3", "test3"));
+        assert_eq!(c.iter().count(), 4);
+
+        c.signed(&key).add(Cookie::new("signed", "signed"));
+        c.private(&key).add(Cookie::new("encrypted", "encrypted"));
+        assert_eq!(c.iter().count(), 6);
+
+        c.remove(Cookie::named("test"));
+        assert_eq!(c.iter().count(), 5);
+
+        c.remove(Cookie::named("signed"));
+        c.remove(Cookie::named("test2"));
+        assert_eq!(c.iter().count(), 3);
+
+        c.add(Cookie::new("test2", "test2"));
+        assert_eq!(c.iter().count(), 4);
+
+        c.remove(Cookie::named("test2"));
+        assert_eq!(c.iter().count(), 3);
+    }
+
+    #[test]
+    #[cfg(feature = "secure-cookies")]
+    fn delta() {
+        use chrono::Duration;
+        use std::collections::HashMap;
+
+        let mut c = CookieJar::new();
+
+        c.add_original(Cookie::new("original", "original"));
+        c.add_original(Cookie::new("original1", "original1"));
+
+        c.add(Cookie::new("test", "test"));
+        c.add(Cookie::new("test2", "test2"));
+        c.add(Cookie::new("test3", "test3"));
+        c.add(Cookie::new("test4", "test4"));
+
+        c.remove(Cookie::named("test"));
+        c.remove(Cookie::named("original"));
+
+        assert_eq!(c.delta().count(), 4);
+
+        let names: HashMap<_, _> = c.delta().map(|c| (c.name(), c.max_age())).collect();
+
+        assert!(names.get("test2").unwrap().is_none());
+        assert!(names.get("test3").unwrap().is_none());
+        assert!(names.get("test4").unwrap().is_none());
+        assert_eq!(names.get("original").unwrap(), &Some(Duration::seconds(0)));
+    }
+
+    #[test]
+    fn replace_original() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("original_a", "a"));
+        jar.add_original(Cookie::new("original_b", "b"));
+        assert_eq!(jar.get("original_a").unwrap().value(), "a");
+
+        jar.add(Cookie::new("original_a", "av2"));
+        assert_eq!(jar.get("original_a").unwrap().value(), "av2");
+    }
+
+    #[test]
+    fn empty_delta() {
+        let mut jar = CookieJar::new();
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().count(), 1);
+    }
+
+    #[test]
+    fn add_remove_add() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        // The cookie's been deleted. Another original doesn't change that.
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().count(), 1);
+    }
+
+    #[test]
+    fn replace_remove() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 0);
+
+        jar.add(Cookie::new("name", "val"));
+        assert_eq!(jar.delta().count(), 1);
+        assert_eq!(jar.delta().filter(|c| !c.value().is_empty()).count(), 1);
+
+        jar.remove(Cookie::named("name"));
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+    }
+
+    #[test]
+    fn remove_with_path() {
+        let mut jar = CookieJar::new();
+        jar.add_original(Cookie::build("name", "val").finish());
+        assert_eq!(jar.iter().count(), 1);
+        assert_eq!(jar.delta().count(), 0);
+        assert_eq!(jar.iter().filter(|c| c.path().is_none()).count(), 1);
+
+        jar.remove(Cookie::build("name", "").path("/").finish());
+        assert_eq!(jar.iter().count(), 0);
+        assert_eq!(jar.delta().count(), 1);
+        assert_eq!(jar.delta().filter(|c| c.value().is_empty()).count(), 1);
+        assert_eq!(jar.delta().filter(|c| c.path() == Some("/")).count(), 1);
+    }
+}
--- a/actix-http/src/cookie/mod.rs
+++ b/actix-http/src/cookie/mod.rs
--- a/actix-http/src/cookie/parse.rs
+++ b/actix-http/src/cookie/parse.rs
@ -0,0 +1,421 @@
+use std::borrow::Cow;
+use std::cmp;
+use std::convert::From;
+use std::error::Error;
+use std::fmt;
+use std::str::Utf8Error;
+
+use chrono::Duration;
+use percent_encoding::percent_decode;
+
+use super::{Cookie, CookieStr, SameSite};
+
+/// Enum corresponding to a parsing error.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum ParseError {
+    /// The cookie did not contain a name/value pair.
+    MissingPair,
+    /// The cookie's name was empty.
+    EmptyName,
+    /// Decoding the cookie's name or value resulted in invalid UTF-8.
+    Utf8Error(Utf8Error),
+    /// It is discouraged to exhaustively match on this enum as its variants may
+    /// grow without a breaking-change bump in version numbers.
+    #[doc(hidden)]
+    __Nonexhasutive,
+}
+
+impl ParseError {
+    /// Returns a description of this error as a string
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            ParseError::MissingPair => "the cookie is missing a name/value pair",
+            ParseError::EmptyName => "the cookie's name is empty",
+            ParseError::Utf8Error(_) => {
+                "decoding the cookie's name or value resulted in invalid UTF-8"
+            }
+            ParseError::__Nonexhasutive => unreachable!("__Nonexhasutive ParseError"),
+        }
+    }
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl From<Utf8Error> for ParseError {
+    fn from(error: Utf8Error) -> ParseError {
+        ParseError::Utf8Error(error)
+    }
+}
+
+impl Error for ParseError {}
+
+fn indexes_of(needle: &str, haystack: &str) -> Option<(usize, usize)> {
+    let haystack_start = haystack.as_ptr() as usize;
+    let needle_start = needle.as_ptr() as usize;
+
+    if needle_start < haystack_start {
+        return None;
+    }
+
+    if (needle_start + needle.len()) > (haystack_start + haystack.len()) {
+        return None;
+    }
+
+    let start = needle_start - haystack_start;
+    let end = start + needle.len();
+    Some((start, end))
+}
+
+fn name_val_decoded(
+    name: &str,
+    val: &str,
+) -> Result<(CookieStr, CookieStr), ParseError> {
+    let decoded_name = percent_decode(name.as_bytes()).decode_utf8()?;
+    let decoded_value = percent_decode(val.as_bytes()).decode_utf8()?;
+    let name = CookieStr::Concrete(Cow::Owned(decoded_name.into_owned()));
+    let val = CookieStr::Concrete(Cow::Owned(decoded_value.into_owned()));
+
+    Ok((name, val))
+}
+
+// This function does the real parsing but _does not_ set the `cookie_string` in
+// the returned cookie object. This only exists so that the borrow to `s` is
+// returned at the end of the call, allowing the `cookie_string` field to be
+// set in the outer `parse` function.
+fn parse_inner<'c>(s: &str, decode: bool) -> Result<Cookie<'c>, ParseError> {
+    let mut attributes = s.split(';');
+    let key_value = match attributes.next() {
+        Some(s) => s,
+        _ => panic!(),
+    };
+
+    // Determine the name = val.
+    let (name, value) = match key_value.find('=') {
+        Some(i) => (key_value[..i].trim(), key_value[(i + 1)..].trim()),
+        None => return Err(ParseError::MissingPair),
+    };
+
+    if name.is_empty() {
+        return Err(ParseError::EmptyName);
+    }
+
+    // Create a cookie with all of the defaults. We'll fill things in while we
+    // iterate through the parameters below.
+    let (name, value) = if decode {
+        name_val_decoded(name, value)?
+    } else {
+        let name_indexes = indexes_of(name, s).expect("name sub");
+        let value_indexes = indexes_of(value, s).expect("value sub");
+        let name = CookieStr::Indexed(name_indexes.0, name_indexes.1);
+        let value = CookieStr::Indexed(value_indexes.0, value_indexes.1);
+
+        (name, value)
+    };
+
+    let mut cookie = Cookie {
+        name,
+        value,
+        cookie_string: None,
+        expires: None,
+        max_age: None,
+        domain: None,
+        path: None,
+        secure: None,
+        http_only: None,
+        same_site: None,
+    };
+
+    for attr in attributes {
+        let (key, value) = match attr.find('=') {
+            Some(i) => (attr[..i].trim(), Some(attr[(i + 1)..].trim())),
+            None => (attr.trim(), None),
+        };
+
+        match (&*key.to_ascii_lowercase(), value) {
+            ("secure", _) => cookie.secure = Some(true),
+            ("httponly", _) => cookie.http_only = Some(true),
+            ("max-age", Some(v)) => {
+                // See RFC 6265 Section 5.2.2, negative values indicate that the
+                // earliest possible expiration time should be used, so set the
+                // max age as 0 seconds.
+                cookie.max_age = match v.parse() {
+                    Ok(val) if val <= 0 => Some(Duration::zero()),
+                    Ok(val) => {
+                        // Don't panic if the max age seconds is greater than what's supported by
+                        // `Duration`.
+                        let val = cmp::min(val, Duration::max_value().num_seconds());
+                        Some(Duration::seconds(val))
+                    }
+                    Err(_) => continue,
+                };
+            }
+            ("domain", Some(mut domain)) if !domain.is_empty() => {
+                if domain.starts_with('.') {
+                    domain = &domain[1..];
+                }
+
+                let (i, j) = indexes_of(domain, s).expect("domain sub");
+                cookie.domain = Some(CookieStr::Indexed(i, j));
+            }
+            ("path", Some(v)) => {
+                let (i, j) = indexes_of(v, s).expect("path sub");
+                cookie.path = Some(CookieStr::Indexed(i, j));
+            }
+            ("samesite", Some(v)) => {
+                if v.eq_ignore_ascii_case("strict") {
+                    cookie.same_site = Some(SameSite::Strict);
+                } else if v.eq_ignore_ascii_case("lax") {
+                    cookie.same_site = Some(SameSite::Lax);
+                } else {
+                    // We do nothing here, for now. When/if the `SameSite`
+                    // attribute becomes standard, the spec says that we should
+                    // ignore this cookie, i.e, fail to parse it, when an
+                    // invalid value is passed in. The draft is at
+                    // http://httpwg.org/http-extensions/draft-ietf-httpbis-cookie-same-site.html.
+                }
+            }
+            ("expires", Some(v)) => {
+                // Try strptime with three date formats according to
+                // http://tools.ietf.org/html/rfc2616#section-3.3.1. Try
+                // additional ones as encountered in the real world.
+                let tm = time::strptime(v, "%a, %d %b %Y %H:%M:%S %Z")
+                    .or_else(|_| time::strptime(v, "%A, %d-%b-%y %H:%M:%S %Z"))
+                    .or_else(|_| time::strptime(v, "%a, %d-%b-%Y %H:%M:%S %Z"))
+                    .or_else(|_| time::strptime(v, "%a %b %d %H:%M:%S %Y"));
+
+                if let Ok(time) = tm {
+                    cookie.expires = Some(time)
+                }
+            }
+            _ => {
+                // We're going to be permissive here. If we have no idea what
+                // this is, then it's something nonstandard. We're not going to
+                // store it (because it's not compliant), but we're also not
+                // going to emit an error.
+            }
+        }
+    }
+
+    Ok(cookie)
+}
+
+pub fn parse_cookie<'c, S>(cow: S, decode: bool) -> Result<Cookie<'c>, ParseError>
+where
+    S: Into<Cow<'c, str>>,
+{
+    let s = cow.into();
+    let mut cookie = parse_inner(&s, decode)?;
+    cookie.cookie_string = Some(s);
+    Ok(cookie)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Cookie, SameSite};
+    use chrono::Duration;
+    use time::strptime;
+
+    macro_rules! assert_eq_parse {
+        ($string:expr, $expected:expr) => {
+            let cookie = match Cookie::parse($string) {
+                Ok(cookie) => cookie,
+                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
+            };
+
+            assert_eq!(cookie, $expected);
+        };
+    }
+
+    macro_rules! assert_ne_parse {
+        ($string:expr, $expected:expr) => {
+            let cookie = match Cookie::parse($string) {
+                Ok(cookie) => cookie,
+                Err(e) => panic!("Failed to parse {:?}: {:?}", $string, e),
+            };
+
+            assert_ne!(cookie, $expected);
+        };
+    }
+
+    #[test]
+    fn parse_same_site() {
+        let expected = Cookie::build("foo", "bar")
+            .same_site(SameSite::Lax)
+            .finish();
+
+        assert_eq_parse!("foo=bar; SameSite=Lax", expected);
+        assert_eq_parse!("foo=bar; SameSite=lax", expected);
+        assert_eq_parse!("foo=bar; SameSite=LAX", expected);
+        assert_eq_parse!("foo=bar; samesite=Lax", expected);
+        assert_eq_parse!("foo=bar; SAMESITE=Lax", expected);
+
+        let expected = Cookie::build("foo", "bar")
+            .same_site(SameSite::Strict)
+            .finish();
+
+        assert_eq_parse!("foo=bar; SameSite=Strict", expected);
+        assert_eq_parse!("foo=bar; SameSITE=Strict", expected);
+        assert_eq_parse!("foo=bar; SameSite=strict", expected);
+        assert_eq_parse!("foo=bar; SameSite=STrICT", expected);
+        assert_eq_parse!("foo=bar; SameSite=STRICT", expected);
+    }
+
+    #[test]
+    fn parse() {
+        assert!(Cookie::parse("bar").is_err());
+        assert!(Cookie::parse("=bar").is_err());
+        assert!(Cookie::parse(" =bar").is_err());
+        assert!(Cookie::parse("foo=").is_ok());
+
+        let expected = Cookie::build("foo", "bar=baz").finish();
+        assert_eq_parse!("foo=bar=baz", expected);
+
+        let mut expected = Cookie::build("foo", "bar").finish();
+        assert_eq_parse!("foo=bar", expected);
+        assert_eq_parse!("foo = bar", expected);
+        assert_eq_parse!(" foo=bar ", expected);
+        assert_eq_parse!(" foo=bar ;Domain=", expected);
+        assert_eq_parse!(" foo=bar ;Domain= ", expected);
+        assert_eq_parse!(" foo=bar ;Ignored", expected);
+
+        let mut unexpected = Cookie::build("foo", "bar").http_only(false).finish();
+        assert_ne_parse!(" foo=bar ;HttpOnly", unexpected);
+        assert_ne_parse!(" foo=bar; httponly", unexpected);
+
+        expected.set_http_only(true);
+        assert_eq_parse!(" foo=bar ;HttpOnly", expected);
+        assert_eq_parse!(" foo=bar ;httponly", expected);
+        assert_eq_parse!(" foo=bar ;HTTPONLY=whatever", expected);
+        assert_eq_parse!(" foo=bar ; sekure; HTTPONLY", expected);
+
+        expected.set_secure(true);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure=aaaa", expected);
+
+        unexpected.set_http_only(true);
+        unexpected.set_secure(true);
+        assert_ne_parse!(" foo=bar ;HttpOnly; skeure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; =secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly;", unexpected);
+
+        unexpected.set_secure(false);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; secure", unexpected);
+
+        expected.set_max_age(Duration::zero());
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=0", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0 ", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=-1", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", expected);
+
+        expected.set_max_age(Duration::minutes(1));
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=60", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age =   60 ", expected);
+
+        expected.set_max_age(Duration::seconds(4));
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=4", expected);
+        assert_eq_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 4 ", expected);
+
+        unexpected.set_secure(true);
+        unexpected.set_max_age(Duration::minutes(1));
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=122", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 38 ", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age=51", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = -1 ", unexpected);
+        assert_ne_parse!(" foo=bar ;HttpOnly; Secure; Max-Age = 0", unexpected);
+
+        expected.set_path("/");
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/", expected);
+
+        expected.set_path("/foo");
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path=/foo", expected);
+        assert_eq_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;path = /foo", expected);
+
+        unexpected.set_max_age(Duration::seconds(4));
+        unexpected.set_path("/bar");
+        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4; Path=/foo", unexpected);
+        assert_ne_parse!("foo=bar;HttpOnly; Secure; Max-Age=4;Path=/baz", unexpected);
+
+        expected.set_domain("www.foo.com");
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=www.foo.com",
+            expected
+        );
+
+        expected.set_domain("foo.com");
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com",
+            expected
+        );
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=FOO.COM",
+            expected
+        );
+
+        unexpected.set_path("/foo");
+        unexpected.set_domain("bar.com");
+        assert_ne_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com",
+            unexpected
+        );
+        assert_ne_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=FOO.COM",
+            unexpected
+        );
+
+        let time_str = "Wed, 21 Oct 2015 07:28:00 GMT";
+        let expires = strptime(time_str, "%a, %d %b %Y %H:%M:%S %Z").unwrap();
+        expected.set_expires(expires);
+        assert_eq_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
+            expected
+        );
+
+        unexpected.set_domain("foo.com");
+        let bad_expires = strptime(time_str, "%a, %d %b %Y %H:%S:%M %Z").unwrap();
+        expected.set_expires(bad_expires);
+        assert_ne_parse!(
+            " foo=bar ;HttpOnly; Secure; Max-Age=4; Path=/foo; \
+             Domain=foo.com; Expires=Wed, 21 Oct 2015 07:28:00 GMT",
+            unexpected
+        );
+    }
+
+    #[test]
+    fn odd_characters() {
+        let expected = Cookie::new("foo", "b%2Fr");
+        assert_eq_parse!("foo=b%2Fr", expected);
+    }
+
+    #[test]
+    fn odd_characters_encoded() {
+        let expected = Cookie::new("foo", "b/r");
+        let cookie = match Cookie::parse_encoded("foo=b%2Fr") {
+            Ok(cookie) => cookie,
+            Err(e) => panic!("Failed to parse: {:?}", e),
+        };
+
+        assert_eq!(cookie, expected);
+    }
+
+    #[test]
+    fn do_not_panic_on_large_max_ages() {
+        let max_seconds = Duration::max_value().num_seconds();
+        let expected = Cookie::build("foo", "bar").max_age(max_seconds).finish();
+        assert_eq_parse!(format!(" foo=bar; Max-Age={:?}", max_seconds + 1), expected);
+    }
+}
--- a/actix-http/src/cookie/secure/key.rs
+++ b/actix-http/src/cookie/secure/key.rs
@ -0,0 +1,190 @@
+use ring::hkdf::{Algorithm, KeyType, Prk, HKDF_SHA256};
+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"];
+
+/// A cryptographic master key for use with `Signed` and/or `Private` jars.
+///
+/// This structure encapsulates secure, cryptographic keys for use with both
+/// [PrivateJar](struct.PrivateJar.html) and [SignedJar](struct.SignedJar.html).
+/// It can be derived from a single master key via
+/// [from_master](#method.from_master) or generated from a secure random source
+/// via [generate](#method.generate). A single instance of `Key` can be used for
+/// both a `PrivateJar` and a `SignedJar`.
+///
+/// This type is only available when the `secure` feature is enabled.
+#[derive(Clone)]
+pub struct Key {
+    signing_key: [u8; SIGNED_KEY_LEN],
+    encryption_key: [u8; PRIVATE_KEY_LEN],
+}
+
+impl 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.
+    ///
+    /// The master key must be at least 256-bits (32 bytes). For security, the
+    /// master key _must_ be cryptographically random. The keys are derived
+    /// deterministically from the master key.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `key` is less than 32 bytes in length.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// # /*
+    /// let master_key = { /* a cryptographically random key >= 32 bytes */ };
+    /// # */
+    /// # let master_key: &Vec<u8> = &(0..32).collect();
+    ///
+    /// let key = Key::from_master(master_key);
+    /// ```
+    pub fn from_master(key: &[u8]) -> Key {
+        if key.len() < 32 {
+            panic!(
+                "bad master key length: expected at least 32 bytes, found {}",
+                key.len()
+            );
+        }
+
+        // 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.
+        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");
+
+        // 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
+    }
+
+    /// Generates signing/encryption keys from a secure, random source. Keys are
+    /// generated nondeterministically.
+    ///
+    /// # Panics
+    ///
+    /// Panics if randomness cannot be retrieved from the operating system. See
+    /// [try_generate](#method.try_generate) for a non-panicking version.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// ```
+    pub fn generate() -> Key {
+        Self::try_generate().expect("failed to generate `Key` from randomness")
+    }
+
+    /// Attempts to generate signing/encryption keys from a secure, random
+    /// source. Keys are generated nondeterministically. If randomness cannot be
+    /// retrieved from the underlying operating system, returns `None`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::try_generate();
+    /// ```
+    pub fn try_generate() -> Option<Key> {
+        let mut sign_key = [0; SIGNED_KEY_LEN];
+        let mut enc_key = [0; PRIVATE_KEY_LEN];
+
+        let rng = SystemRandom::new();
+        if rng.fill(&mut sign_key).is_err() || rng.fill(&mut enc_key).is_err() {
+            return None;
+        }
+
+        Some(Key {
+            signing_key: sign_key,
+            encryption_key: enc_key,
+        })
+    }
+
+    /// Returns the raw bytes of a key suitable for signing cookies.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// let signing_key = key.signing();
+    /// ```
+    pub fn signing(&self) -> &[u8] {
+        &self.signing_key[..]
+    }
+
+    /// Returns the raw bytes of a key suitable for encrypting cookies.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::Key;
+    ///
+    /// let key = Key::generate();
+    /// let encryption_key = key.encryption();
+    /// ```
+    pub fn encryption(&self) -> &[u8] {
+        &self.encryption_key[..]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Key;
+
+    #[test]
+    fn deterministic_from_master() {
+        let master_key: Vec<u8> = (0..32).collect();
+
+        let key_a = Key::from_master(&master_key);
+        let key_b = Key::from_master(&master_key);
+
+        assert_eq!(key_a.signing(), key_b.signing());
+        assert_eq!(key_a.encryption(), key_b.encryption());
+        assert_ne!(key_a.encryption(), key_a.signing());
+
+        let master_key_2: Vec<u8> = (32..64).collect();
+        let key_2 = Key::from_master(&master_key_2);
+
+        assert_ne!(key_2.signing(), key_a.signing());
+        assert_ne!(key_2.encryption(), key_a.encryption());
+    }
+
+    #[test]
+    fn non_deterministic_generate() {
+        let key_a = Key::generate();
+        let key_b = Key::generate();
+
+        assert_ne!(key_a.signing(), key_b.signing());
+        assert_ne!(key_a.encryption(), key_b.encryption());
+    }
+}
--- a/actix-http/src/cookie/secure/macros.rs
+++ b/actix-http/src/cookie/secure/macros.rs
@ -0,0 +1,40 @@
+#[cfg(test)]
+macro_rules! assert_simple_behaviour {
+    ($clear:expr, $secure:expr) => {{
+        assert_eq!($clear.iter().count(), 0);
+
+        $secure.add(Cookie::new("name", "val"));
+        assert_eq!($clear.iter().count(), 1);
+        assert_eq!($secure.get("name").unwrap().value(), "val");
+        assert_ne!($clear.get("name").unwrap().value(), "val");
+
+        $secure.add(Cookie::new("another", "two"));
+        assert_eq!($clear.iter().count(), 2);
+
+        $clear.remove(Cookie::named("another"));
+        assert_eq!($clear.iter().count(), 1);
+
+        $secure.remove(Cookie::named("name"));
+        assert_eq!($clear.iter().count(), 0);
+    }};
+}
+
+#[cfg(test)]
+macro_rules! assert_secure_behaviour {
+    ($clear:expr, $secure:expr) => {{
+        $secure.add(Cookie::new("secure", "secure"));
+        assert!($clear.get("secure").unwrap().value() != "secure");
+        assert!($secure.get("secure").unwrap().value() == "secure");
+
+        let mut cookie = $clear.get("secure").unwrap().clone();
+        let new_val = format!("{}l", cookie.value());
+        cookie.set_value(new_val);
+        $clear.add(cookie);
+        assert!($secure.get("secure").is_none());
+
+        let mut cookie = $clear.get("secure").unwrap().clone();
+        cookie.set_value("foobar");
+        $clear.add(cookie);
+        assert!($secure.get("secure").is_none());
+    }};
+}
--- a/actix-http/src/cookie/secure/mod.rs
+++ b/actix-http/src/cookie/secure/mod.rs
@ -0,0 +1,10 @@
+//! Fork of https://github.com/alexcrichton/cookie-rs
+#[macro_use]
+mod macros;
+mod key;
+mod private;
+mod signed;
+
+pub use self::key::*;
+pub use self::private::*;
+pub use self::signed::*;
--- a/actix-http/src/cookie/secure/private.rs
+++ b/actix-http/src/cookie/secure/private.rs
@ -0,0 +1,275 @@
+use std::str;
+
+use log::warn;
+use ring::aead::{Aad, Algorithm, Nonce, AES_256_GCM};
+use ring::aead::{LessSafeKey, UnboundKey};
+use ring::rand::{SecureRandom, SystemRandom};
+
+use super::Key;
+use crate::cookie::{Cookie, CookieJar};
+
+// Keep these in sync, and keep the key len synced with the `private` docs as
+// well as the `KEYS_INFO` const in secure::Key.
+static ALGO: &Algorithm = &AES_256_GCM;
+const NONCE_LEN: usize = 12;
+pub const KEY_LEN: usize = 32;
+
+/// A child cookie jar that provides authenticated encryption for its cookies.
+///
+/// A _private_ child jar signs and encrypts all the cookies added to it and
+/// verifies and decrypts cookies retrieved from it. Any cookies stored in a
+/// `PrivateJar` are simultaneously assured confidentiality, integrity, and
+/// authenticity. In other words, clients cannot discover nor tamper with the
+/// contents of a cookie, nor can they fabricate cookie data.
+///
+/// This type is only available when the `secure` feature is enabled.
+pub struct PrivateJar<'a> {
+    parent: &'a mut CookieJar,
+    key: [u8; KEY_LEN],
+}
+
+impl<'a> PrivateJar<'a> {
+    /// Creates a new child `PrivateJar` with parent `parent` and key `key`.
+    /// This method is typically called indirectly via the `signed` method of
+    /// `CookieJar`.
+    #[doc(hidden)]
+    pub fn new(parent: &'a mut CookieJar, key: &Key) -> PrivateJar<'a> {
+        let mut key_array = [0u8; KEY_LEN];
+        key_array.copy_from_slice(key.encryption());
+        PrivateJar {
+            parent,
+            key: key_array,
+        }
+    }
+
+    /// Given a sealed value `str` and a key name `name`, where the nonce is
+    /// prepended to the original value and then both are Base64 encoded,
+    /// verifies and decrypts the sealed value and returns it. If there's a
+    /// problem, returns an `Err` with a string describing the issue.
+    fn unseal(&self, name: &str, value: &str) -> Result<String, &'static str> {
+        let mut data = base64::decode(value).map_err(|_| "bad base64 value")?;
+        if data.len() <= NONCE_LEN {
+            return Err("length of decoded data is <= NONCE_LEN");
+        }
+
+        let ad = Aad::from(name.as_bytes());
+        let key = LessSafeKey::new(
+            UnboundKey::new(&ALGO, &self.key).expect("matching key length"),
+        );
+        let (nonce, mut 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)
+            .map_err(|_| "invalid key/nonce/value: bad seal")?;
+
+        if let Ok(unsealed_utf8) = str::from_utf8(unsealed) {
+            Ok(unsealed_utf8.to_string())
+        } else {
+            warn!(
+                "Private cookie does not have utf8 content!
+It is likely the secret key used to encrypt them has been leaked.
+Please change it as soon as possible."
+            );
+            Err("bad unsealed utf8")
+        }
+    }
+
+    /// Returns a reference to the `Cookie` inside this jar with the name `name`
+    /// and authenticates and decrypts the cookie's value, returning a `Cookie`
+    /// with the decrypted value. If the cookie cannot be found, or the cookie
+    /// fails to authenticate or decrypt, `None` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut private_jar = jar.private(&key);
+    /// assert!(private_jar.get("name").is_none());
+    ///
+    /// private_jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(private_jar.get("name").unwrap().value(), "value");
+    /// ```
+    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
+        if let Some(cookie_ref) = self.parent.get(name) {
+            let mut cookie = cookie_ref.clone();
+            if let Ok(value) = self.unseal(name, cookie.value()) {
+                cookie.set_value(value);
+                return Some(cookie);
+            }
+        }
+
+        None
+    }
+
+    /// Adds `cookie` to the parent jar. The cookie's value is encrypted with
+    /// authenticated encryption assuring confidentiality, integrity, and
+    /// authenticity.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.private(&key).add(Cookie::new("name", "value"));
+    ///
+    /// assert_ne!(jar.get("name").unwrap().value(), "value");
+    /// assert_eq!(jar.private(&key).get("name").unwrap().value(), "value");
+    /// ```
+    pub fn add(&mut self, mut cookie: Cookie<'static>) {
+        self.encrypt_cookie(&mut cookie);
+
+        // Add the sealed cookie to the parent.
+        self.parent.add(cookie);
+    }
+
+    /// Adds an "original" `cookie` to parent jar. The cookie's value is
+    /// encrypted with authenticated encryption assuring confidentiality,
+    /// integrity, and authenticity. Adding an original cookie does not affect
+    /// the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
+    /// computation. This method is intended to be used to seed the cookie jar
+    /// with cookies received from a client's HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.private(&key).add_original(Cookie::new("name", "value"));
+    ///
+    /// assert_eq!(jar.iter().count(), 1);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
+        self.encrypt_cookie(&mut cookie);
+
+        // Add the sealed cookie to the parent.
+        self.parent.add_original(cookie);
+    }
+
+    /// Encrypts the cookie's value with
+    /// authenticated encryption assuring confidentiality, integrity, and authenticity.
+    fn encrypt_cookie(&self, cookie: &mut Cookie<'_>) {
+        let name = cookie.name().as_bytes();
+        let value = cookie.value().as_bytes();
+        let data = encrypt_name_value(name, value, &self.key);
+
+        // Base64 encode the nonce and encrypted value.
+        let sealed_value = base64::encode(&data);
+        cookie.set_value(sealed_value);
+    }
+
+    /// Removes `cookie` from the parent jar.
+    ///
+    /// For correct removal, the passed in `cookie` must contain the same `path`
+    /// and `domain` as the cookie that was initially set.
+    ///
+    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
+    /// details.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut private_jar = jar.private(&key);
+    ///
+    /// private_jar.add(Cookie::new("name", "value"));
+    /// assert!(private_jar.get("name").is_some());
+    ///
+    /// private_jar.remove(Cookie::named("name"));
+    /// assert!(private_jar.get("name").is_none());
+    /// ```
+    pub fn remove(&mut self, cookie: Cookie<'static>) {
+        self.parent.remove(cookie);
+    }
+}
+
+fn encrypt_name_value(name: &[u8], value: &[u8], key: &[u8]) -> Vec<u8> {
+    // Create the `SealingKey` structure.
+    let unbound = UnboundKey::new(&ALGO, key).expect("matching key length");
+    let key = LessSafeKey::new(unbound);
+
+    // Create a vec to hold the [nonce | cookie value | overhead].
+    let mut data = vec![0; NONCE_LEN + value.len() + ALGO.tag_len()];
+
+    // 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");
+
+    // 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());
+
+    // Remove the overhead and return the sealed content.
+    data
+}
+
+#[cfg(test)]
+mod test {
+    use super::{encrypt_name_value, Cookie, CookieJar, Key};
+
+    #[test]
+    fn simple() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_simple_behaviour!(jar, jar.private(&key));
+    }
+
+    #[test]
+    fn private() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_secure_behaviour!(jar, jar.private(&key));
+    }
+
+    #[test]
+    fn non_utf8() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+
+        let name = "malicious";
+        let mut assert_non_utf8 = |value: &[u8]| {
+            let sealed = encrypt_name_value(name.as_bytes(), value, &key.encryption());
+            let encoded = base64::encode(&sealed);
+            assert_eq!(
+                jar.private(&key).unseal(name, &encoded),
+                Err("bad unsealed utf8")
+            );
+            jar.add(Cookie::new(name, encoded));
+            assert_eq!(jar.private(&key).get(name), None);
+        };
+
+        assert_non_utf8(&[0x72, 0xfb, 0xdf, 0x74]); // rûst in ISO/IEC 8859-1
+
+        let mut malicious =
+            String::from(r#"{"id":"abc123??%X","admin":true}"#).into_bytes();
+        malicious[8] |= 0b1100_0000;
+        malicious[9] |= 0b1100_0000;
+        assert_non_utf8(&malicious);
+    }
+}
--- a/actix-http/src/cookie/secure/signed.rs
+++ b/actix-http/src/cookie/secure/signed.rs
@ -0,0 +1,184 @@
+use ring::hmac::{self, sign, verify};
+
+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;
+const BASE64_DIGEST_LEN: usize = 44;
+pub const KEY_LEN: usize = 32;
+
+/// A child cookie jar that authenticates its cookies.
+///
+/// A _signed_ child jar signs all the cookies added to it and verifies cookies
+/// retrieved from it. Any cookies stored in a `SignedJar` are assured integrity
+/// and authenticity. In other words, clients cannot tamper with the contents of
+/// a cookie nor can they fabricate cookie values, but the data is visible in
+/// plaintext.
+///
+/// This type is only available when the `secure` feature is enabled.
+pub struct SignedJar<'a> {
+    parent: &'a mut CookieJar,
+    key: hmac::Key,
+}
+
+impl<'a> SignedJar<'a> {
+    /// Creates a new child `SignedJar` with parent `parent` and key `key`. This
+    /// method is typically called indirectly via the `signed` method of
+    /// `CookieJar`.
+    #[doc(hidden)]
+    pub fn new(parent: &'a mut CookieJar, key: &Key) -> SignedJar<'a> {
+        SignedJar {
+            parent,
+            key: hmac::Key::new(HMAC_DIGEST, key.signing()),
+        }
+    }
+
+    /// Given a signed value `str` where the signature is prepended to `value`,
+    /// verifies the signed value and returns it. If there's a problem, returns
+    /// an `Err` with a string describing the issue.
+    fn verify(&self, cookie_value: &str) -> Result<String, &'static str> {
+        if cookie_value.len() < BASE64_DIGEST_LEN {
+            return Err("length of value is <= BASE64_DIGEST_LEN");
+        }
+
+        let (digest_str, value) = cookie_value.split_at(BASE64_DIGEST_LEN);
+        let sig = base64::decode(digest_str).map_err(|_| "bad base64 digest")?;
+
+        verify(&self.key, value.as_bytes(), &sig)
+            .map(|_| value.to_string())
+            .map_err(|_| "value did not verify")
+    }
+
+    /// Returns a reference to the `Cookie` inside this jar with the name `name`
+    /// and verifies the authenticity and integrity of the cookie's value,
+    /// returning a `Cookie` with the authenticated value. If the cookie cannot
+    /// be found, or the cookie fails to verify, `None` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut signed_jar = jar.signed(&key);
+    /// assert!(signed_jar.get("name").is_none());
+    ///
+    /// signed_jar.add(Cookie::new("name", "value"));
+    /// assert_eq!(signed_jar.get("name").unwrap().value(), "value");
+    /// ```
+    pub fn get(&self, name: &str) -> Option<Cookie<'static>> {
+        if let Some(cookie_ref) = self.parent.get(name) {
+            let mut cookie = cookie_ref.clone();
+            if let Ok(value) = self.verify(cookie.value()) {
+                cookie.set_value(value);
+                return Some(cookie);
+            }
+        }
+
+        None
+    }
+
+    /// Adds `cookie` to the parent jar. The cookie's value is signed assuring
+    /// integrity and authenticity.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.signed(&key).add(Cookie::new("name", "value"));
+    ///
+    /// assert_ne!(jar.get("name").unwrap().value(), "value");
+    /// assert!(jar.get("name").unwrap().value().contains("value"));
+    /// assert_eq!(jar.signed(&key).get("name").unwrap().value(), "value");
+    /// ```
+    pub fn add(&mut self, mut cookie: Cookie<'static>) {
+        self.sign_cookie(&mut cookie);
+        self.parent.add(cookie);
+    }
+
+    /// Adds an "original" `cookie` to this jar. The cookie's value is signed
+    /// assuring integrity and authenticity. Adding an original cookie does not
+    /// affect the [`CookieJar::delta()`](struct.CookieJar.html#method.delta)
+    /// computation. This method is intended to be used to seed the cookie jar
+    /// with cookies received from a client's HTTP message.
+    ///
+    /// For accurate `delta` computations, this method should not be called
+    /// after calling `remove`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// jar.signed(&key).add_original(Cookie::new("name", "value"));
+    ///
+    /// assert_eq!(jar.iter().count(), 1);
+    /// assert_eq!(jar.delta().count(), 0);
+    /// ```
+    pub fn add_original(&mut self, mut cookie: Cookie<'static>) {
+        self.sign_cookie(&mut cookie);
+        self.parent.add_original(cookie);
+    }
+
+    /// Signs the cookie's value assuring integrity and authenticity.
+    fn sign_cookie(&self, cookie: &mut Cookie<'_>) {
+        let digest = sign(&self.key, cookie.value().as_bytes());
+        let mut new_value = base64::encode(digest.as_ref());
+        new_value.push_str(cookie.value());
+        cookie.set_value(new_value);
+    }
+
+    /// Removes `cookie` from the parent jar.
+    ///
+    /// For correct removal, the passed in `cookie` must contain the same `path`
+    /// and `domain` as the cookie that was initially set.
+    ///
+    /// See [CookieJar::remove](struct.CookieJar.html#method.remove) for more
+    /// details.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use actix_http::cookie::{CookieJar, Cookie, Key};
+    ///
+    /// let key = Key::generate();
+    /// let mut jar = CookieJar::new();
+    /// let mut signed_jar = jar.signed(&key);
+    ///
+    /// signed_jar.add(Cookie::new("name", "value"));
+    /// assert!(signed_jar.get("name").is_some());
+    ///
+    /// signed_jar.remove(Cookie::named("name"));
+    /// assert!(signed_jar.get("name").is_none());
+    /// ```
+    pub fn remove(&mut self, cookie: Cookie<'static>) {
+        self.parent.remove(cookie);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Cookie, CookieJar, Key};
+
+    #[test]
+    fn simple() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_simple_behaviour!(jar, jar.signed(&key));
+    }
+
+    #[test]
+    fn private() {
+        let key = Key::generate();
+        let mut jar = CookieJar::new();
+        assert_secure_behaviour!(jar, jar.signed(&key));
+    }
+}
--- a/actix-http/src/encoding/encoder.rs
+++ b/actix-http/src/encoding/encoder.rs
@ -9,7 +9,6 @@ use brotli2::write::BrotliEncoder;
 use bytes::Bytes;
 use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
-use pin_project::pin_project;

 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::http::header::{ContentEncoding, CONTENT_ENCODING};
@ -20,10 +19,8 @@ use super::Writer;

 const INPLACE: usize = 1024;

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

-#[pin_project(project = EncoderBodyProj)]
 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(),
-        }
-    }
-
-    fn poll_next(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
-        match self.project() {
-            EncoderBodyProj::Bytes(b) => {
-                if b.is_empty() {
-                    Poll::Ready(None)
-                } else {
-                    Poll::Ready(Some(Ok(std::mem::take(b))))
-                }
-            }
-            EncoderBodyProj::Stream(b) => b.poll_next(cx),
-            EncoderBodyProj::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, cx: &mut Context<'_>) -> Poll<Option<Result<Bytes, Error>>> {
        loop {
-            if *this.eof {
+            if self.eof {
                return Poll::Ready(None);
            }

-            if let Some(ref mut fut) = this.fut {
+            if let Some(ref mut fut) = self.fut {
                let mut encoder = match ready!(Pin::new(fut).poll(cx)) {
                    Ok(item) => item,
                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
                };
                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)));
                }
            }

-            let result = this.body.as_mut().poll_next(cx);
-
+            let result = match self.body {
+                EncoderBody::Bytes(ref mut b) => {
+                    if b.is_empty() {
+                        Poll::Ready(None)
+                    } else {
+                        Poll::Ready(Some(Ok(std::mem::replace(b, Bytes::new()))))
+                    }
+                }
+                EncoderBody::Stream(ref mut b) => b.poll_next(cx),
+                EncoderBody::BoxedStream(ref mut b) => b.poll_next(cx),
+            };
            match result {
                Poll::Ready(Some(Ok(chunk))) => {
-                    if let Some(mut encoder) = this.encoder.take() {
+                    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)));
                            }
                        } else {
-                            *this.fut = Some(run(move || {
+                            self.fut = Some(run(move || {
                                encoder.write(&chunk)?;
                                Ok(encoder)
                            }));
@ -170,12 +146,12 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                    }
                }
                Poll::Ready(None) => {
-                    if let Some(encoder) = this.encoder.take() {
+                    if let Some(encoder) = self.encoder.take() {
                        let chunk = encoder.finish()?;
                        if chunk.is_empty() {
                            return Poll::Ready(None);
                        } else {
-                            *this.eof = true;
+                            self.eof = true;
                            return Poll::Ready(Some(Ok(chunk)));
                        }
                    } else {
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
@ -1,4 +1,5 @@
 //! Error and Result module
+use std::any::TypeId;
 use std::cell::RefCell;
 use std::io::Write;
 use std::str::Utf8Error;
@ -14,11 +15,12 @@ use derive_more::{Display, From};
 pub use futures_channel::oneshot::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;

-// re-export for convenience
+// re-export for convinience
 use crate::body::Body;
 pub use crate::cookie::ParseError as CookieParseError;
 use crate::helpers::Writer;
@ -34,7 +36,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()`.
 ///
@ -81,10 +83,25 @@ 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 {
@ -333,8 +350,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)
@ -432,7 +447,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,8 +458,6 @@ pub enum ContentTypeError {
    UnknownEncoding,
 }

-impl std::error::Error for ContentTypeError {}
-
 /// Return `BadRequest` for `ContentTypeError`
 impl ResponseError for ContentTypeError {
    fn status_code(&self) -> StatusCode {
@ -950,15 +963,9 @@ 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 = "actors")]
-/// `InternalServerError` for `actix::ResolverError`
-/// This is supported on feature=`actors` only
-impl ResponseError for actix::actors::resolver::ResolverError {}
+#[cfg(feature = "failure")]
+/// Compatibility for `failure::Error`
+impl ResponseError for fail_ure::Error {}

 #[cfg(test)]
 mod tests {
--- a/actix-http/src/extensions.rs
+++ b/actix-http/src/extensions.rs
@ -6,8 +6,6 @@ use fxhash::FxHashMap;
 #[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>>,
 }

@ -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.
@ -69,113 +70,22 @@ impl fmt::Debug for Extensions {
    }
 }

-#[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/decoder.rs
+++ b/actix-http/src/h1/decoder.rs
@ -8,6 +8,7 @@ use actix_codec::Decoder;
 use bytes::{Buf, Bytes, BytesMut};
 use http::header::{HeaderName, HeaderValue};
 use http::{header, Method, StatusCode, Uri, Version};
+use httparse;
 use log::{debug, error, trace};

 use crate::error::ParseError;
@ -18,7 +19,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)]
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@ -10,7 +10,6 @@ use actix_service::Service;
 use bitflags::bitflags;
 use bytes::{Buf, BytesMut};
 use log::{error, trace};
-use pin_project::pin_project;

 use crate::body::{Body, BodySize, MessageBody, ResponseBody};
 use crate::cloneable::CloneableService;
@ -42,7 +41,6 @@ bitflags! {
    }
 }

-#[pin_project::pin_project]
 /// Dispatcher for HTTP/1.1 protocol
 pub struct Dispatcher<T, S, B, X, U>
 where
@ -54,11 +52,9 @@ where
    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
-    #[pin]
    inner: DispatcherState<T, S, B, X, U>,
 }

-#[pin_project(project = DispatcherStateProj)]
 enum DispatcherState<T, S, B, X, U>
 where
    S: Service<Request = Request>,
@ -69,11 +65,11 @@ where
    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
-    Normal(#[pin] InnerDispatcher<T, S, B, X, U>),
-    Upgrade(Pin<Box<U::Future>>),
+    Normal(InnerDispatcher<T, S, B, X, U>),
+    Upgrade(U::Future),
+    None,
 }

-#[pin_project(project = InnerDispatcherProj)]
 struct InnerDispatcher<T, S, B, X, U>
 where
    S: Service<Request = Request>,
@ -92,7 +88,6 @@ where
    peer_addr: Option<net::SocketAddr>,
    error: Option<DispatchError>,

-    #[pin]
    state: State<S, B, X>,
    payload: Option<PayloadSender>,
    messages: VecDeque<DispatcherMessage>,
@ -100,7 +95,7 @@ where
    ka_expire: Instant,
    ka_timer: Option<Delay>,

-    io: Option<T>,
+    io: T,
    read_buf: BytesMut,
    write_buf: BytesMut,
    codec: Codec,
@ -112,7 +107,6 @@ enum DispatcherMessage {
    Error(Response<()>),
 }

-#[pin_project(project = StateProj)]
 enum State<S, B, X>
 where
    S: Service<Request = Request>,
@ -120,9 +114,9 @@ where
    B: MessageBody,
 {
    None,
-    ExpectCall(Pin<Box<X::Future>>),
-    ServiceCall(Pin<Box<S::Future>>),
-    SendPayload(#[pin] ResponseBody<B>),
+    ExpectCall(X::Future),
+    ServiceCall(S::Future),
+    SendPayload(ResponseBody<B>),
 }

 impl<S, B, X> State<S, B, X>
@ -147,6 +141,7 @@ where
        }
    }
 }
+
 enum PollResponse {
    Upgrade(Request),
    DoNothing,
@ -241,7 +236,7 @@ where
                state: State::None,
                error: None,
                messages: VecDeque::new(),
-                io: Some(io),
+                io,
                codec,
                read_buf,
                service,
@ -283,33 +278,29 @@ where
    }

    // if checked is set to true, delay disconnect until all tasks have finished.
-    fn client_disconnected(self: Pin<&mut Self>) {
-        let this = self.project();
-        this.flags
+    fn client_disconnected(&mut self) {
+        self.flags
            .insert(Flags::READ_DISCONNECT | Flags::WRITE_DISCONNECT);
-        if let Some(mut payload) = this.payload.take() {
+        if let Some(mut payload) = self.payload.take() {
            payload.set_error(PayloadError::Incomplete(None));
        }
    }

    /// Flush stream
    ///
-    /// true - got WouldBlock
-    /// false - didn't get WouldBlock
-    fn poll_flush(
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Result<bool, DispatchError> {
+    /// true - got whouldblock
+    /// false - didnt get whouldblock
+    fn poll_flush(&mut self, cx: &mut Context<'_>) -> Result<bool, DispatchError> {
        if self.write_buf.is_empty() {
            return Ok(false);
        }

        let len = self.write_buf.len();
        let mut written = 0;
-        let InnerDispatcherProj { io, write_buf, .. } = self.project();
-        let mut io = Pin::new(io.as_mut().unwrap());
        while written < len {
-            match io.as_mut().poll_write(cx, &write_buf[written..]) {
+            match unsafe { Pin::new_unchecked(&mut self.io) }
+                .poll_write(cx, &self.write_buf[written..])
+            {
                Poll::Ready(Ok(0)) => {
                    return Err(DispatchError::Io(io::Error::new(
                        io::ErrorKind::WriteZero,
@ -321,117 +312,112 @@ where
                }
                Poll::Pending => {
                    if written > 0 {
-                        write_buf.advance(written);
+                        self.write_buf.advance(written);
                    }
                    return Ok(true);
                }
                Poll::Ready(Err(err)) => return Err(DispatchError::Io(err)),
            }
        }
-        if written == write_buf.len() {
-            unsafe { write_buf.set_len(0) }
+        if written == self.write_buf.len() {
+            unsafe { self.write_buf.set_len(0) }
        } else {
-            write_buf.advance(written);
+            self.write_buf.advance(written);
        }
        Ok(false)
    }

    fn send_response(
-        self: Pin<&mut Self>,
+        &mut self,
        message: Response<()>,
        body: ResponseBody<B>,
    ) -> Result<State<S, B, X>, DispatchError> {
-        let mut this = self.project();
-        this.codec
-            .encode(Message::Item((message, body.size())), &mut this.write_buf)
+        self.codec
+            .encode(Message::Item((message, body.size())), &mut self.write_buf)
            .map_err(|err| {
-                if let Some(mut payload) = this.payload.take() {
+                if let Some(mut payload) = self.payload.take() {
                    payload.set_error(PayloadError::Incomplete(None));
                }
                DispatchError::Io(err)
            })?;

-        this.flags.set(Flags::KEEPALIVE, this.codec.keepalive());
+        self.flags.set(Flags::KEEPALIVE, self.codec.keepalive());
        match body.size() {
            BodySize::None | BodySize::Empty => Ok(State::None),
            _ => Ok(State::SendPayload(body)),
        }
    }

-    fn send_continue(self: Pin<&mut Self>) {
-        self.project()
-            .write_buf
+    fn send_continue(&mut self) {
+        self.write_buf
            .extend_from_slice(b"HTTP/1.1 100 Continue\r\n\r\n");
    }

    fn poll_response(
-        mut self: Pin<&mut Self>,
+        &mut self,
        cx: &mut Context<'_>,
    ) -> Result<PollResponse, DispatchError> {
        loop {
-            let mut this = self.as_mut().project();
-            let state = match this.state.project() {
-                StateProj::None => match this.messages.pop_front() {
+            let state = match self.state {
+                State::None => match self.messages.pop_front() {
                    Some(DispatcherMessage::Item(req)) => {
-                        Some(self.as_mut().handle_request(req, cx)?)
+                        Some(self.handle_request(req, cx)?)
+                    }
+                    Some(DispatcherMessage::Error(res)) => {
+                        Some(self.send_response(res, ResponseBody::Other(Body::Empty))?)
                    }
-                    Some(DispatcherMessage::Error(res)) => Some(
-                        self.as_mut()
-                            .send_response(res, ResponseBody::Other(Body::Empty))?,
-                    ),
                    Some(DispatcherMessage::Upgrade(req)) => {
                        return Ok(PollResponse::Upgrade(req));
                    }
                    None => None,
                },
-                StateProj::ExpectCall(fut) => match fut.as_mut().poll(cx) {
-                    Poll::Ready(Ok(req)) => {
-                        self.as_mut().send_continue();
-                        this = self.as_mut().project();
-                        this.state
-                            .set(State::ServiceCall(Box::pin(this.service.call(req))));
-                        continue;
+                State::ExpectCall(ref mut fut) => {
+                    match unsafe { Pin::new_unchecked(fut) }.poll(cx) {
+                        Poll::Ready(Ok(req)) => {
+                            self.send_continue();
+                            self.state = State::ServiceCall(self.service.call(req));
+                            continue;
+                        }
+                        Poll::Ready(Err(e)) => {
+                            let res: Response = e.into().into();
+                            let (res, body) = res.replace_body(());
+                            Some(self.send_response(res, body.into_body())?)
+                        }
+                        Poll::Pending => None,
                    }
-                    Poll::Ready(Err(e)) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-                        Some(self.as_mut().send_response(res, body.into_body())?)
+                }
+                State::ServiceCall(ref mut fut) => {
+                    match unsafe { Pin::new_unchecked(fut) }.poll(cx) {
+                        Poll::Ready(Ok(res)) => {
+                            let (res, body) = res.into().replace_body(());
+                            self.state = self.send_response(res, body)?;
+                            continue;
+                        }
+                        Poll::Ready(Err(e)) => {
+                            let res: Response = e.into().into();
+                            let (res, body) = res.replace_body(());
+                            Some(self.send_response(res, body.into_body())?)
+                        }
+                        Poll::Pending => None,
                    }
-                    Poll::Pending => None,
-                },
-                StateProj::ServiceCall(fut) => match fut.as_mut().poll(cx) {
-                    Poll::Ready(Ok(res)) => {
-                        let (res, body) = res.into().replace_body(());
-                        let state = self.as_mut().send_response(res, body)?;
-                        this = self.as_mut().project();
-                        this.state.set(state);
-                        continue;
-                    }
-                    Poll::Ready(Err(e)) => {
-                        let res: Response = e.into().into();
-                        let (res, body) = res.replace_body(());
-                        Some(self.as_mut().send_response(res, body.into_body())?)
-                    }
-                    Poll::Pending => None,
-                },
-                StateProj::SendPayload(mut stream) => {
+                }
+                State::SendPayload(ref mut stream) => {
                    loop {
-                        if this.write_buf.len() < HW_BUFFER_SIZE {
-                            match stream.as_mut().poll_next(cx) {
+                        if self.write_buf.len() < HW_BUFFER_SIZE {
+                            match stream.poll_next(cx) {
                                Poll::Ready(Some(Ok(item))) => {
-                                    this.codec.encode(
+                                    self.codec.encode(
                                        Message::Chunk(Some(item)),
-                                        &mut this.write_buf,
+                                        &mut self.write_buf,
                                    )?;
                                    continue;
                                }
                                Poll::Ready(None) => {
-                                    this.codec.encode(
+                                    self.codec.encode(
                                        Message::Chunk(None),
-                                        &mut this.write_buf,
+                                        &mut self.write_buf,
                                    )?;
-                                    this = self.as_mut().project();
-                                    this.state.set(State::None);
+                                    self.state = State::None;
                                }
                                Poll::Ready(Some(Err(_))) => {
                                    return Err(DispatchError::Unknown)
@ -447,11 +433,9 @@ where
                }
            };

-            this = self.as_mut().project();
-
            // set new state
            if let Some(state) = state {
-                this.state.set(state);
+                self.state = state;
                if !self.state.is_empty() {
                    continue;
                }
@ -459,7 +443,7 @@ where
                // if read-backpressure is enabled and we consumed some data.
                // we may read more data and retry
                if self.state.is_call() {
-                    if self.as_mut().poll_request(cx)? {
+                    if self.poll_request(cx)? {
                        continue;
                    }
                } else if !self.messages.is_empty() {
@ -473,16 +457,16 @@ where
    }

    fn handle_request(
-        mut self: Pin<&mut Self>,
+        &mut self,
        req: Request,
        cx: &mut Context<'_>,
    ) -> Result<State<S, B, X>, DispatchError> {
        // Handle `EXPECT: 100-Continue` header
        let req = if req.head().expect() {
-            let mut task = Box::pin(self.as_mut().project().expect.call(req));
-            match task.as_mut().poll(cx) {
+            let mut task = self.expect.call(req);
+            match unsafe { Pin::new_unchecked(&mut task) }.poll(cx) {
                Poll::Ready(Ok(req)) => {
-                    self.as_mut().send_continue();
+                    self.send_continue();
                    req
                }
                Poll::Pending => return Ok(State::ExpectCall(task)),
@ -498,8 +482,8 @@ where
        };

        // Call service
-        let mut task = Box::pin(self.as_mut().project().service.call(req));
-        match task.as_mut().poll(cx) {
+        let mut task = self.service.call(req);
+        match unsafe { Pin::new_unchecked(&mut task) }.poll(cx) {
            Poll::Ready(Ok(res)) => {
                let (res, body) = res.into().replace_body(());
                self.send_response(res, body)
@ -515,7 +499,7 @@ where

    /// Process one incoming requests
    pub(self) fn poll_request(
-        mut self: Pin<&mut Self>,
+        &mut self,
        cx: &mut Context<'_>,
    ) -> Result<bool, DispatchError> {
        // limit a mount of non processed requests
@ -524,25 +508,24 @@ where
        }

        let mut updated = false;
-        let mut this = self.as_mut().project();
        loop {
-            match this.codec.decode(&mut this.read_buf) {
+            match self.codec.decode(&mut self.read_buf) {
                Ok(Some(msg)) => {
                    updated = true;
-                    this.flags.insert(Flags::STARTED);
+                    self.flags.insert(Flags::STARTED);

                    match msg {
                        Message::Item(mut req) => {
-                            let pl = this.codec.message_type();
-                            req.head_mut().peer_addr = *this.peer_addr;
+                            let pl = self.codec.message_type();
+                            req.head_mut().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());
                            }

-                            if pl == MessageType::Stream && this.upgrade.is_some() {
-                                this.messages.push_back(DispatcherMessage::Upgrade(req));
+                            if pl == MessageType::Stream && self.upgrade.is_some() {
+                                self.messages.push_back(DispatcherMessage::Upgrade(req));
                                break;
                            }
                            if pl == MessageType::Payload || pl == MessageType::Stream {
@ -550,43 +533,41 @@ where
                                let (req1, _) =
                                    req.replace_payload(crate::Payload::H1(pl));
                                req = req1;
-                                *this.payload = Some(ps);
+                                self.payload = Some(ps);
                            }

                            // handle request early
-                            if this.state.is_empty() {
-                                let state = self.as_mut().handle_request(req, cx)?;
-                                this = self.as_mut().project();
-                                this.state.set(state);
+                            if self.state.is_empty() {
+                                self.state = self.handle_request(req, cx)?;
                            } else {
-                                this.messages.push_back(DispatcherMessage::Item(req));
+                                self.messages.push_back(DispatcherMessage::Item(req));
                            }
                        }
                        Message::Chunk(Some(chunk)) => {
-                            if let Some(ref mut payload) = this.payload {
+                            if let Some(ref mut payload) = self.payload {
                                payload.feed_data(chunk);
                            } else {
                                error!(
                                    "Internal server error: unexpected payload chunk"
                                );
-                                this.flags.insert(Flags::READ_DISCONNECT);
-                                this.messages.push_back(DispatcherMessage::Error(
+                                self.flags.insert(Flags::READ_DISCONNECT);
+                                self.messages.push_back(DispatcherMessage::Error(
                                    Response::InternalServerError().finish().drop_body(),
                                ));
-                                *this.error = Some(DispatchError::InternalError);
+                                self.error = Some(DispatchError::InternalError);
                                break;
                            }
                        }
                        Message::Chunk(None) => {
-                            if let Some(mut payload) = this.payload.take() {
+                            if let Some(mut payload) = self.payload.take() {
                                payload.feed_eof();
                            } else {
                                error!("Internal server error: unexpected eof");
-                                this.flags.insert(Flags::READ_DISCONNECT);
-                                this.messages.push_back(DispatcherMessage::Error(
+                                self.flags.insert(Flags::READ_DISCONNECT);
+                                self.messages.push_back(DispatcherMessage::Error(
                                    Response::InternalServerError().finish().drop_body(),
                                ));
-                                *this.error = Some(DispatchError::InternalError);
+                                self.error = Some(DispatchError::InternalError);
                                break;
                            }
                        }
@ -594,49 +575,44 @@ where
                }
                Ok(None) => break,
                Err(ParseError::Io(e)) => {
-                    self.as_mut().client_disconnected();
-                    this = self.as_mut().project();
-                    *this.error = Some(DispatchError::Io(e));
+                    self.client_disconnected();
+                    self.error = Some(DispatchError::Io(e));
                    break;
                }
                Err(e) => {
-                    if let Some(mut payload) = this.payload.take() {
+                    if let Some(mut payload) = self.payload.take() {
                        payload.set_error(PayloadError::EncodingCorrupted);
                    }

                    // Malformed requests should be responded with 400
-                    this.messages.push_back(DispatcherMessage::Error(
+                    self.messages.push_back(DispatcherMessage::Error(
                        Response::BadRequest().finish().drop_body(),
                    ));
-                    this.flags.insert(Flags::READ_DISCONNECT);
-                    *this.error = Some(e.into());
+                    self.flags.insert(Flags::READ_DISCONNECT);
+                    self.error = Some(e.into());
                    break;
                }
            }
        }

-        if updated && this.ka_timer.is_some() {
-            if let Some(expire) = this.codec.config().keep_alive_expire() {
-                *this.ka_expire = expire;
+        if updated && self.ka_timer.is_some() {
+            if let Some(expire) = self.codec.config().keep_alive_expire() {
+                self.ka_expire = expire;
            }
        }
        Ok(updated)
    }

    /// keep-alive timer
-    fn poll_keepalive(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Result<(), DispatchError> {
-        let mut this = self.as_mut().project();
-        if this.ka_timer.is_none() {
+    fn poll_keepalive(&mut self, cx: &mut Context<'_>) -> Result<(), DispatchError> {
+        if self.ka_timer.is_none() {
            // shutdown timeout
-            if this.flags.contains(Flags::SHUTDOWN) {
-                if let Some(interval) = this.codec.config().client_disconnect_timer() {
-                    *this.ka_timer = Some(delay_until(interval));
+            if self.flags.contains(Flags::SHUTDOWN) {
+                if let Some(interval) = self.codec.config().client_disconnect_timer() {
+                    self.ka_timer = Some(delay_until(interval));
                } else {
-                    this.flags.insert(Flags::READ_DISCONNECT);
-                    if let Some(mut payload) = this.payload.take() {
+                    self.flags.insert(Flags::READ_DISCONNECT);
+                    if let Some(mut payload) = self.payload.take() {
                        payload.set_error(PayloadError::Incomplete(None));
                    }
                    return Ok(());
@ -646,56 +622,55 @@ where
            }
        }

-        match Pin::new(&mut this.ka_timer.as_mut().unwrap()).poll(cx) {
+        match Pin::new(&mut self.ka_timer.as_mut().unwrap()).poll(cx) {
            Poll::Ready(()) => {
                // if we get timeout during shutdown, drop connection
-                if this.flags.contains(Flags::SHUTDOWN) {
+                if self.flags.contains(Flags::SHUTDOWN) {
                    return Err(DispatchError::DisconnectTimeout);
-                } else if this.ka_timer.as_mut().unwrap().deadline() >= *this.ka_expire {
+                } else if self.ka_timer.as_mut().unwrap().deadline() >= self.ka_expire {
                    // check for any outstanding tasks
-                    if this.state.is_empty() && this.write_buf.is_empty() {
-                        if this.flags.contains(Flags::STARTED) {
+                    if self.state.is_empty() && self.write_buf.is_empty() {
+                        if self.flags.contains(Flags::STARTED) {
                            trace!("Keep-alive timeout, close connection");
-                            this.flags.insert(Flags::SHUTDOWN);
+                            self.flags.insert(Flags::SHUTDOWN);

                            // start shutdown timer
                            if let Some(deadline) =
-                                this.codec.config().client_disconnect_timer()
+                                self.codec.config().client_disconnect_timer()
                            {
-                                if let Some(mut timer) = this.ka_timer.as_mut() {
+                                if let Some(mut timer) = self.ka_timer.as_mut() {
                                    timer.reset(deadline);
                                    let _ = Pin::new(&mut timer).poll(cx);
                                }
                            } else {
                                // no shutdown timeout, drop socket
-                                this.flags.insert(Flags::WRITE_DISCONNECT);
+                                self.flags.insert(Flags::WRITE_DISCONNECT);
                                return Ok(());
                            }
                        } else {
                            // timeout on first request (slow request) return 408
-                            if !this.flags.contains(Flags::STARTED) {
+                            if !self.flags.contains(Flags::STARTED) {
                                trace!("Slow request timeout");
-                                let _ = self.as_mut().send_response(
+                                let _ = self.send_response(
                                    Response::RequestTimeout().finish().drop_body(),
                                    ResponseBody::Other(Body::Empty),
                                );
-                                this = self.as_mut().project();
                            } else {
                                trace!("Keep-alive connection timeout");
                            }
-                            this.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
-                            this.state.set(State::None);
+                            self.flags.insert(Flags::STARTED | Flags::SHUTDOWN);
+                            self.state = State::None;
                        }
                    } else if let Some(deadline) =
-                        this.codec.config().keep_alive_expire()
+                        self.codec.config().keep_alive_expire()
                    {
-                        if let Some(mut timer) = this.ka_timer.as_mut() {
+                        if let Some(mut timer) = self.ka_timer.as_mut() {
                            timer.reset(deadline);
                            let _ = Pin::new(&mut timer).poll(cx);
                        }
                    }
-                } else if let Some(mut timer) = this.ka_timer.as_mut() {
-                    timer.reset(*this.ka_expire);
+                } else if let Some(mut timer) = self.ka_timer.as_mut() {
+                    timer.reset(self.ka_expire);
                    let _ = Pin::new(&mut timer).poll(cx);
                }
            }
@ -706,6 +681,20 @@ where
    }
 }

+impl<T, S, B, X, U> Unpin for Dispatcher<T, S, B, X, U>
+where
+    T: AsyncRead + AsyncWrite + Unpin,
+    S: Service<Request = Request>,
+    S::Error: Into<Error>,
+    S::Response: Into<Response<B>>,
+    B: MessageBody,
+    X: Service<Request = Request, Response = Request>,
+    X::Error: Into<Error>,
+    U: Service<Request = (Request, Framed<T, Codec>), Response = ()>,
+    U::Error: fmt::Display,
+{
+}
+
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
    T: AsyncRead + AsyncWrite + Unpin,
@ -722,25 +711,20 @@ where

    #[inline]
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.as_mut().project();
-        match this.inner.project() {
-            DispatcherStateProj::Normal(mut inner) => {
-                inner.as_mut().poll_keepalive(cx)?;
+        match self.as_mut().inner {
+            DispatcherState::Normal(ref mut inner) => {
+                inner.poll_keepalive(cx)?;

                if inner.flags.contains(Flags::SHUTDOWN) {
                    if inner.flags.contains(Flags::WRITE_DISCONNECT) {
                        Poll::Ready(Ok(()))
                    } else {
                        // flush buffer
-                        inner.as_mut().poll_flush(cx)?;
-                        if !inner.write_buf.is_empty() || inner.io.is_none() {
+                        inner.poll_flush(cx)?;
+                        if !inner.write_buf.is_empty() {
                            Poll::Pending
                        } else {
-                            match Pin::new(inner.project().io)
-                                .as_pin_mut()
-                                .unwrap()
-                                .poll_shutdown(cx)
-                            {
+                            match Pin::new(&mut inner.io).poll_shutdown(cx) {
                                Poll::Ready(res) => {
                                    Poll::Ready(res.map_err(DispatchError::from))
                                }
@ -752,58 +736,53 @@ where
                    // read socket into a buf
                    let should_disconnect =
                        if !inner.flags.contains(Flags::READ_DISCONNECT) {
-                            let mut inner_p = inner.as_mut().project();
-                            read_available(
-                                cx,
-                                inner_p.io.as_mut().unwrap(),
-                                &mut inner_p.read_buf,
-                            )?
+                            read_available(cx, &mut inner.io, &mut inner.read_buf)?
                        } else {
                            None
                        };

-                    inner.as_mut().poll_request(cx)?;
+                    inner.poll_request(cx)?;
                    if let Some(true) = should_disconnect {
-                        let inner_p = inner.as_mut().project();
-                        inner_p.flags.insert(Flags::READ_DISCONNECT);
-                        if let Some(mut payload) = inner_p.payload.take() {
+                        inner.flags.insert(Flags::READ_DISCONNECT);
+                        if let Some(mut payload) = inner.payload.take() {
                            payload.feed_eof();
                        }
                    };

                    loop {
-                        let inner_p = inner.as_mut().project();
                        let remaining =
-                            inner_p.write_buf.capacity() - inner_p.write_buf.len();
+                            inner.write_buf.capacity() - inner.write_buf.len();
                        if remaining < LW_BUFFER_SIZE {
-                            inner_p.write_buf.reserve(HW_BUFFER_SIZE - remaining);
+                            inner.write_buf.reserve(HW_BUFFER_SIZE - remaining);
                        }
-                        let result = inner.as_mut().poll_response(cx)?;
+                        let result = inner.poll_response(cx)?;
                        let drain = result == PollResponse::DrainWriteBuf;

                        // switch to upgrade handler
                        if let PollResponse::Upgrade(req) = result {
-                            let inner_p = inner.as_mut().project();
-                            let mut parts = FramedParts::with_read_buf(
-                                inner_p.io.take().unwrap(),
-                                std::mem::take(inner_p.codec),
-                                std::mem::take(inner_p.read_buf),
-                            );
-                            parts.write_buf = std::mem::take(inner_p.write_buf);
-                            let framed = Framed::from_parts(parts);
-                            let upgrade =
-                                inner_p.upgrade.take().unwrap().call((req, framed));
-                            self.as_mut()
-                                .project()
-                                .inner
-                                .set(DispatcherState::Upgrade(Box::pin(upgrade)));
-                            return self.poll(cx);
+                            if let DispatcherState::Normal(inner) =
+                                std::mem::replace(&mut self.inner, DispatcherState::None)
+                            {
+                                let mut parts = FramedParts::with_read_buf(
+                                    inner.io,
+                                    inner.codec,
+                                    inner.read_buf,
+                                );
+                                parts.write_buf = inner.write_buf;
+                                let framed = Framed::from_parts(parts);
+                                self.inner = DispatcherState::Upgrade(
+                                    inner.upgrade.unwrap().call((req, framed)),
+                                );
+                                return self.poll(cx);
+                            } else {
+                                panic!()
+                            }
                        }

-                        // we didn't get WouldBlock from write operation,
+                        // we didnt get WouldBlock from write operation,
                        // so data get written to kernel completely (OSX)
                        // and we have to write again otherwise response can get stuck
-                        if inner.as_mut().poll_flush(cx)? || !drain {
+                        if inner.poll_flush(cx)? || !drain {
                            break;
                        }
                    }
@ -815,26 +794,25 @@ where

                    let is_empty = inner.state.is_empty();

-                    let inner_p = inner.as_mut().project();
                    // read half is closed and we do not processing any responses
-                    if inner_p.flags.contains(Flags::READ_DISCONNECT) && is_empty {
-                        inner_p.flags.insert(Flags::SHUTDOWN);
+                    if inner.flags.contains(Flags::READ_DISCONNECT) && is_empty {
+                        inner.flags.insert(Flags::SHUTDOWN);
                    }

                    // keep-alive and stream errors
-                    if is_empty && inner_p.write_buf.is_empty() {
-                        if let Some(err) = inner_p.error.take() {
+                    if is_empty && inner.write_buf.is_empty() {
+                        if let Some(err) = inner.error.take() {
                            Poll::Ready(Err(err))
                        }
                        // disconnect if keep-alive is not enabled
-                        else if inner_p.flags.contains(Flags::STARTED)
-                            && !inner_p.flags.intersects(Flags::KEEPALIVE)
+                        else if inner.flags.contains(Flags::STARTED)
+                            && !inner.flags.intersects(Flags::KEEPALIVE)
                        {
-                            inner_p.flags.insert(Flags::SHUTDOWN);
+                            inner.flags.insert(Flags::SHUTDOWN);
                            self.poll(cx)
                        }
                        // disconnect if shutdown
-                        else if inner_p.flags.contains(Flags::SHUTDOWN) {
+                        else if inner.flags.contains(Flags::SHUTDOWN) {
                            self.poll(cx)
                        } else {
                            Poll::Pending
@ -844,10 +822,13 @@ where
                    }
                }
            }
-            DispatcherStateProj::Upgrade(fut) => fut.as_mut().poll(cx).map_err(|e| {
-                error!("Upgrade handler error: {}", e);
-                DispatchError::Upgrade
-            }),
+            DispatcherState::Upgrade(ref mut fut) => {
+                unsafe { Pin::new_unchecked(fut) }.poll(cx).map_err(|e| {
+                    error!("Upgrade handler error: {}", e);
+                    DispatchError::Upgrade
+                })
+            }
+            DispatcherState::None => panic!(),
        }
    }
 }
@ -861,14 +842,7 @@ where
    T: AsyncRead + Unpin,
 {
    let mut read_some = false;
-
    loop {
-        // If buf is full return but do not disconnect since
-        // there is more reading to be done
-        if buf.len() >= HW_BUFFER_SIZE {
-            return Ok(Some(false));
-        }
-
        let remaining = buf.capacity() - buf.len();
        if remaining < LW_BUFFER_SIZE {
            buf.reserve(HW_BUFFER_SIZE - remaining);
@ -944,12 +918,9 @@ mod tests {
                Poll::Ready(res) => assert!(res.is_err()),
            }

-            if let DispatcherState::Normal(ref mut inner) = h1.inner {
+            if let DispatcherState::Normal(ref inner) = h1.inner {
                assert!(inner.flags.contains(Flags::READ_DISCONNECT));
-                assert_eq!(
-                    &inner.io.take().unwrap().write_buf[..26],
-                    b"HTTP/1.1 400 Bad Request\r\n"
-                );
+                assert_eq!(&inner.io.write_buf[..26], b"HTTP/1.1 400 Bad Request\r\n");
            }
        })
        .await;
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@ -4,7 +4,7 @@ use std::ptr::copy_nonoverlapping;
 use std::slice::from_raw_parts_mut;
 use std::{cmp, io};

-use bytes::{BufMut, BytesMut};
+use bytes::{buf::BufMutExt, BufMut, BytesMut};

 use crate::body::BodySize;
 use crate::config::ServiceConfig;
@ -95,6 +95,15 @@ 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: ");
+                }
+                #[allow(clippy::write_with_newline)]
+                write!(dst.writer(), "{}\r\n", len)?;
+            }
            BodySize::None => dst.put_slice(b"\r\n"),
        }

@ -329,7 +338,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()
@ -572,6 +582,19 @@ mod tests {
        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.split().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"));
--- a/actix-http/src/h1/utils.rs
+++ b/actix-http/src/h1/utils.rs
@ -13,7 +13,6 @@ use crate::response::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,27 +35,24 @@ 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>;

-    // 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 this = self.get_mut();

-        let mut body_done = this.body.is_none();
        loop {
-            let mut body_ready = !body_done;
+            let mut body_ready = this.body.is_some();
            let framed = this.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)? {
+            if this.res.is_none() && this.body.is_some() {
+                while body_ready && this.body.is_some() && !framed.is_write_buf_full() {
+                    match this.body.as_mut().unwrap().poll_next(cx)? {
                        Poll::Ready(item) => {
-                            // body is done when item is None
-                            body_done = item.is_none();
-                            if body_done {
+                            // body is done
+                            if item.is_none() {
                                let _ = this.body.take();
                            }
                            framed.write(Message::Chunk(item))?;
@ -86,7 +82,7 @@ where
                continue;
            }

-            if !body_done {
+            if this.body.is_some() {
                if body_ready {
                    continue;
                } else {
--- a/actix-http/src/h2/dispatcher.rs
+++ b/actix-http/src/h2/dispatcher.rs
@ -158,17 +158,15 @@ where

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

-#[pin_project::pin_project(project = ServiceResponseStateProj)]
 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>
@ -210,6 +208,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
@ -248,62 +250,66 @@ where
    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let mut this = self.as_mut().project();

-        match this.state.project() {
-            ServiceResponseStateProj::ServiceCall(call, send) => match call.poll(cx) {
-                Poll::Ready(Ok(res)) => {
-                    let (res, body) = res.into().replace_body(());
+        match this.state {
+            ServiceResponseState::ServiceCall(ref mut call, ref mut send) => {
+                match unsafe { Pin::new_unchecked(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.as_mut().prepare_response(res.head(), &mut size);
-                    this = self.as_mut().project();
+                        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(());
+                        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 =
+                                ServiceResponseState::SendPayload(stream, body);
+                            self.poll(cx)
                        }
-                        Ok(stream) => stream,
-                    };
+                    }
+                    Poll::Pending => Poll::Pending,
+                    Poll::Ready(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.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 = ServiceResponseState::SendPayload(
+                                stream,
+                                body.into_body(),
+                            );
+                            self.poll(cx)
+                        }
                    }
                }
-                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)
-                    }
-                }
-            },
-            ServiceResponseStateProj::SendPayload(ref mut stream, ref mut body) => loop {
+            }
+            ServiceResponseState::SendPayload(ref mut stream, ref mut body) => loop {
                loop {
                    if let Some(ref mut buffer) = this.buffer {
                        match stream.poll_capacity(cx) {
@ -329,7 +335,7 @@ where
                            }
                        }
                    } else {
-                        match body.as_mut().poll_next(cx) {
+                        match body.poll_next(cx) {
                            Poll::Pending => return Poll::Pending,
                            Poll::Ready(None) => {
                                if let Err(e) = stream.send_data(Bytes::new(), true) {
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@ -83,11 +83,13 @@ where
        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))
-            }))
+        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)
    }
--- 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/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,7 +457,7 @@ impl ContentDisposition {
        self.parameters
            .iter()
            .filter_map(|p| p.as_unknown_ext(name))
-            .next()
+            .nth(0)
    }
 }

@ -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();
        }
@ -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 {
@ -833,7 +833,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
--- 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
@ -7,7 +7,7 @@ use http::header::{HeaderName, HeaderValue};

 /// 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)]
--- a/actix-http/src/header/shared/charset.rs
+++ b/actix-http/src/header/shared/charset.rs
@ -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/httpdate.rs
+++ b/actix-http/src/header/shared/httpdate.rs
@ -1,46 +1,59 @@
 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 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)
+        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))
    }
 }

@ -49,51 +62,56 @@ impl IntoHeaderValue for HttpDate {

    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();
+        write!(wrt, "{}", self.0.rfc822()).unwrap();
        HeaderValue::from_maybe_shared(wrt.get_mut().split().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/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_u8(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,28 +196,8 @@ 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();
@ -124,48 +231,5 @@ mod tests {
        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"[..]
-        );
    }
 }
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@ -10,9 +10,6 @@
 #[macro_use]
 extern crate log;

-#[macro_use]
-mod macros;
-
 pub mod body;
 mod builder;
 pub mod client;
@ -30,9 +27,8 @@ mod payload;
 mod request;
 mod response;
 mod service;
-mod time_parser;

-pub use cookie;
+pub mod cookie;
 pub mod error;
 pub mod h1;
 pub mod h2;
--- 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
@ -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 {
--- a/actix-http/src/response.rs
+++ b/actix-http/src/response.rs
@ -9,6 +9,7 @@ use std::{fmt, str};
 use bytes::{Bytes, BytesMut};
 use futures_core::Stream;
 use serde::Serialize;
+use serde_json;

 use crate::body::{Body, BodyStream, MessageBody, ResponseBody};
 use crate::cookie::{Cookie, CookieJar};
@ -472,9 +473,7 @@ impl ResponseBuilder {

    /// Disable chunked transfer encoding for HTTP/1.1 streaming responses.
    #[inline]
-    pub fn no_chunking(&mut self, len: u64) -> &mut Self {
-        self.header(header::CONTENT_LENGTH, len);
-
+    pub fn no_chunking(&mut self) -> &mut Self {
        if let Some(parts) = parts(&mut self.head, &self.err) {
            parts.no_chunking(true);
        }
@ -499,6 +498,12 @@ impl ResponseBuilder {
        self
    }

+    /// Set content length
+    #[inline]
+    pub fn content_length(&mut self, len: u64) -> &mut Self {
+        self.header(header::CONTENT_LENGTH, len)
+    }
+
    /// Set a cookie
    ///
    /// ```rust
@ -632,7 +637,7 @@ impl ResponseBuilder {
    /// `ResponseBuilder` can not be used after this call.
    pub fn streaming<S, E>(&mut self, stream: S) -> Response
    where
-        S: Stream<Item = Result<Bytes, E>> + Unpin + 'static,
+        S: Stream<Item = Result<Bytes, E>> + 'static,
        E: Into<Error> + 'static,
    {
        self.body(Body::from_message(BodyStream::new(stream)))
@ -877,7 +882,7 @@ mod tests {
                    .domain("www.rust-lang.org")
                    .path("/test")
                    .http_only(true)
-                    .max_age(time::Duration::days(1))
+                    .max_age_time(time::Duration::days(1))
                    .finish(),
            )
            .del_cookie(&cookies[1])
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@ -10,7 +10,7 @@ use bytes::Bytes;
 use futures_core::{ready, Future};
 use futures_util::future::ok;
 use h2::server::{self, Handshake};
-use pin_project::pin_project;
+use pin_project::{pin_project, project};

 use crate::body::MessageBody;
 use crate::builder::HttpServiceBuilder;
@ -574,7 +574,7 @@ where
    }
 }

-#[pin_project(project = StateProj)]
+#[pin_project]
 enum State<T, S, B, X, U>
 where
    S: Service<Request = Request>,
@ -650,14 +650,16 @@ where
    U: Service<Request = (Request, Framed<T, h1::Codec>), Response = ()>,
    U::Error: fmt::Display,
 {
+    #[project]
    fn poll(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Result<(), DispatchError>> {
+        #[project]
        match self.as_mut().project() {
-            StateProj::H1(disp) => disp.poll(cx),
-            StateProj::H2(disp) => disp.poll(cx),
-            StateProj::H2Handshake(ref mut data) => {
+            State::H1(disp) => disp.poll(cx),
+            State::H2(disp) => disp.poll(cx),
+            State::H2Handshake(ref mut data) => {
                let conn = if let Some(ref mut item) = data {
                    match Pin::new(&mut item.0).poll(cx) {
                        Poll::Ready(Ok(conn)) => conn,
--- a/actix-http/src/test.rs
+++ b/actix-http/src/test.rs
@ -1,5 +1,6 @@
 //! Test Various helpers for Actix applications to use during testing.
 use std::convert::TryFrom;
+use std::fmt::Write as FmtWrite;
 use std::io::{self, Read, Write};
 use std::pin::Pin;
 use std::str::FromStr;
@ -9,8 +10,9 @@ use actix_codec::{AsyncRead, AsyncWrite};
 use bytes::{Bytes, BytesMut};
 use http::header::{self, HeaderName, HeaderValue};
 use http::{Error as HttpError, Method, Uri, Version};
+use percent_encoding::percent_encode;

-use crate::cookie::{Cookie, CookieJar};
+use crate::cookie::{Cookie, CookieJar, USERINFO};
 use crate::header::HeaderMap;
 use crate::header::{Header, IntoHeaderValue};
 use crate::payload::Payload;
@ -161,17 +163,17 @@ impl TestRequest {
        head.version = inner.version;
        head.headers = inner.headers;

-        let cookie: String = inner
-            .cookies
-            .delta()
-            // ensure only name=value is written to cookie header
-            .map(|c| Cookie::new(c.name(), c.value()).encoded().to_string())
-            .collect::<Vec<_>>()
-            .join("; ");
-
+        let mut cookie = String::new();
+        for c in inner.cookies.delta() {
+            let name = percent_encode(c.name().as_bytes(), USERINFO);
+            let value = percent_encode(c.value().as_bytes(), USERINFO);
+            let _ = write!(&mut cookie, "; {}={}", name, value);
+        }
        if !cookie.is_empty() {
-            head.headers
-                .insert(header::COOKIE, HeaderValue::from_str(&cookie).unwrap());
+            head.headers.insert(
+                header::COOKIE,
+                HeaderValue::from_str(&cookie.as_str()[2..]).unwrap(),
+            );
        }

        req
--- a/actix-http/src/time_parser.rs
+++ b/actix-http/src/time_parser.rs
@ -1,42 +0,0 @@
-use time::{Date, OffsetDateTime, PrimitiveDateTime};
-
-/// Attempt to parse a `time` string as one of either RFC 1123, RFC 850, or asctime.
-pub fn parse_http_date(time: &str) -> Option<PrimitiveDateTime> {
-    try_parse_rfc_1123(time)
-        .or_else(|| try_parse_rfc_850(time))
-        .or_else(|| try_parse_asctime(time))
-}
-
-/// Attempt to parse a `time` string as a RFC 1123 formatted date time string.
-fn try_parse_rfc_1123(time: &str) -> Option<PrimitiveDateTime> {
-    time::parse(time, "%a, %d %b %Y %H:%M:%S").ok()
-}
-
-/// Attempt to parse a `time` string as a RFC 850 formatted date time string.
-fn try_parse_rfc_850(time: &str) -> Option<PrimitiveDateTime> {
-    match PrimitiveDateTime::parse(time, "%A, %d-%b-%y %H:%M:%S") {
-        Ok(dt) => {
-            // If the `time` string contains a two-digit year, then as per RFC 2616 § 19.3,
-            // we consider the year as part of this century if it's within the next 50 years,
-            // otherwise we consider as part of the previous century.
-            let now = OffsetDateTime::now_utc();
-            let century_start_year = (now.year() / 100) * 100;
-            let mut expanded_year = century_start_year + dt.year();
-
-            if expanded_year > now.year() + 50 {
-                expanded_year -= 100;
-            }
-
-            match Date::try_from_ymd(expanded_year, dt.month(), dt.day()) {
-                Ok(date) => Some(PrimitiveDateTime::new(date, dt.time())),
-                Err(_) => None,
-            }
-        }
-        Err(_) => None,
-    }
-}
-
-/// Attempt to parse a `time` string using ANSI C's `asctime` format.
-fn try_parse_asctime(time: &str) -> Option<PrimitiveDateTime> {
-    time::parse(time, "%a %b %_d %H:%M:%S %Y").ok()
-}
--- a/actix-http/src/ws/codec.rs
+++ b/actix-http/src/ws/codec.rs
@ -137,7 +137,7 @@ impl Encoder for Codec {
                        Parser::write_message(
                            dst,
                            &data[..],
-                            OpCode::Text,
+                            OpCode::Binary,
                            false,
                            !self.flags.contains(Flags::SERVER),
                        )
@ -151,7 +151,7 @@ impl Encoder for Codec {
                        Parser::write_message(
                            dst,
                            &data[..],
-                            OpCode::Binary,
+                            OpCode::Text,
                            false,
                            !self.flags.contains(Flags::SERVER),
                        )
--- a/actix-http/src/ws/frame.rs
+++ b/actix-http/src/ws/frame.rs
@ -2,6 +2,7 @@ use std::convert::TryFrom;

 use bytes::{Buf, BufMut, BytesMut};
 use log::debug;
+use rand;

 use crate::ws::mask::apply_mask;
 use crate::ws::proto::{CloseCode, CloseReason, OpCode};
--- a/actix-http/src/ws/mod.rs
+++ b/actix-http/src/ws/mod.rs
@ -58,8 +58,6 @@ pub enum ProtocolError {
    Io(io::Error),
 }

-impl std::error::Error for ProtocolError {}
-
 impl ResponseError for ProtocolError {}

 /// Websocket handshake errors
@ -110,7 +108,7 @@ impl ResponseError for HandshakeError {
    }
 }

-/// Verify `WebSocket` handshake request and create handshake response.
+/// Verify `WebSocket` handshake request and create handshake reponse.
 // /// `protocols` is a sequence of known protocols. On successful handshake,
 // /// the returned response headers contain the first protocol in this list
 // /// which the server also knows.
@ -170,7 +168,7 @@ pub fn verify_handshake(req: &RequestHead) -> Result<(), HandshakeError> {
    Ok(())
 }

-/// Create websocket handshake response
+/// Create websocket's handshake response
 ///
 /// This function returns handshake `Response`, ready to send to peer.
 pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
--- a/actix-http/src/ws/proto.rs
+++ b/actix-http/src/ws/proto.rs
@ -1,3 +1,5 @@
+use base64;
+use sha1;
 use std::convert::{From, Into};
 use std::fmt;

@ -203,15 +205,15 @@ impl<T: Into<String>> From<(CloseCode, T)> for CloseReason {

 static WS_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

-// TODO: hash is always same size, we don't need String
+// TODO: hash is always same size, we dont need String
 pub fn hash_key(key: &[u8]) -> String {
    use sha1::Digest;
    let mut hasher = sha1::Sha1::new();

-    hasher.update(key);
-    hasher.update(WS_GUID.as_bytes());
+    hasher.input(key);
+    hasher.input(WS_GUID.as_bytes());

-    base64::encode(&hasher.finalize())
+    base64::encode(hasher.result().as_ref())
 }

 #[cfg(test)]
--- a/actix-http/tests/test_client.rs
+++ b/actix-http/tests/test_client.rs
@ -1,6 +1,6 @@
 use actix_service::ServiceFactory;
 use bytes::Bytes;
-use futures_util::future::{self, ok};
+use futures::future::{self, ok};

 use actix_http::{http, HttpService, Request, Response};
 use actix_http_test::test_server;
@ -33,8 +33,7 @@ async fn test_h1_v2() {
        HttpService::build()
            .finish(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -62,8 +61,7 @@ async fn test_connection_close() {
            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .tcp()
            .map(|_| ())
-    })
-    .await;
+    });

    let response = srv.get("/").force_close().send().await.unwrap();
    assert!(response.status().is_success());
@ -82,8 +80,7 @@ async fn test_with_query_parameter() {
            })
            .tcp()
            .map(|_| ())
-    })
-    .await;
+    });

    let request = srv.request(http::Method::GET, srv.url("/?qp=5"));
    let response = request.send().await.unwrap();
--- a/actix-http/tests/test_openssl.rs
+++ b/actix-http/tests/test_openssl.rs
@ -5,8 +5,8 @@ use actix_http_test::test_server;
 use actix_service::{fn_service, ServiceFactory};

 use bytes::{Bytes, BytesMut};
-use futures_util::future::{err, ok, ready};
-use futures_util::stream::{once, Stream, StreamExt};
+use futures::future::{err, ok, ready};
+use futures::stream::{once, Stream, StreamExt};
 use open_ssl::ssl::{AlpnError, SslAcceptor, SslFiletype, SslMethod};

 use actix_http::error::{ErrorBadRequest, PayloadError};
@ -67,8 +67,7 @@ async fn test_h2() -> io::Result<()> {
            .h2(|_| ok::<_, Error>(Response::Ok().finish()))
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -86,8 +85,7 @@ async fn test_h2_1() -> io::Result<()> {
            })
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -99,14 +97,15 @@ async fn test_h2_body() -> io::Result<()> {
    let data = "HELLOWORLD".to_owned().repeat(64 * 1024);
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|mut req: Request<_>| async move {
-                let body = load_body(req.take_payload()).await?;
-                Ok::<_, Error>(Response::Ok().body(body))
+            .h2(|mut req: Request<_>| {
+                async move {
+                    let body = load_body(req.take_payload()).await?;
+                    Ok::<_, Error>(Response::Ok().body(body))
+                }
            })
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send_body(data.clone()).await.unwrap();
    assert!(response.status().is_success());
@ -134,8 +133,7 @@ async fn test_h2_content_length() {
            })
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let header = HeaderName::from_static("content-length");
    let value = HeaderValue::from_static("0");
@ -196,7 +194,7 @@ async fn test_h2_headers() {
        })
            .openssl(ssl_acceptor())
                    .map_err(|_| ())
-    }).await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -235,8 +233,7 @@ async fn test_h2_body2() {
            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -253,8 +250,7 @@ async fn test_h2_head_empty() {
            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.shead("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -275,12 +271,11 @@ async fn test_h2_head_binary() {
    let mut srv = test_server(move || {
        HttpService::build()
            .h2(|_| {
-                ok::<_, ()>(Response::Ok().body(STR))
+                ok::<_, ()>(Response::Ok().content_length(STR.len() as u64).body(STR))
            })
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.shead("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -302,8 +297,7 @@ async fn test_h2_head_binary2() {
            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.shead("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -326,8 +320,7 @@ async fn test_h2_body_length() {
            })
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -351,8 +344,7 @@ async fn test_h2_body_chunked_explicit() {
            })
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -379,8 +371,7 @@ async fn test_h2_response_http_error_handling() {
            }))
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert_eq!(response.status(), StatusCode::INTERNAL_SERVER_ERROR);
@ -397,8 +388,7 @@ async fn test_h2_service_error() {
            .h2(|_| err::<Response, Error>(ErrorBadRequest("error")))
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
@ -419,8 +409,7 @@ async fn test_h2_on_connect() {
            })
            .openssl(ssl_acceptor())
            .map_err(|_| ())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
--- a/actix-http/tests/test_rustls.rs
+++ b/actix-http/tests/test_rustls.rs
@ -7,8 +7,8 @@ use actix_http_test::test_server;
 use actix_service::{fn_factory_with_config, fn_service};

 use bytes::{Bytes, BytesMut};
-use futures_util::future::{self, err, ok};
-use futures_util::stream::{once, Stream, StreamExt};
+use futures::future::{self, err, ok};
+use futures::stream::{once, Stream, StreamExt};
 use rust_tls::{
    internal::pemfile::{certs, pkcs8_private_keys},
    NoClientAuth, ServerConfig as RustlsServerConfig,
@ -45,8 +45,7 @@ async fn test_h1() -> io::Result<()> {
        HttpService::build()
            .h1(|_| future::ok::<_, Error>(Response::Ok().finish()))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -59,8 +58,7 @@ async fn test_h2() -> io::Result<()> {
        HttpService::build()
            .h2(|_| future::ok::<_, Error>(Response::Ok().finish()))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -77,8 +75,7 @@ async fn test_h1_1() -> io::Result<()> {
                future::ok::<_, Error>(Response::Ok().finish())
            })
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -95,8 +92,7 @@ async fn test_h2_1() -> io::Result<()> {
                future::ok::<_, Error>(Response::Ok().finish())
            })
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -108,13 +104,14 @@ async fn test_h2_body1() -> io::Result<()> {
    let data = "HELLOWORLD".to_owned().repeat(64 * 1024);
    let mut srv = test_server(move || {
        HttpService::build()
-            .h2(|mut req: Request<_>| async move {
-                let body = load_body(req.take_payload()).await?;
-                Ok::<_, Error>(Response::Ok().body(body))
+            .h2(|mut req: Request<_>| {
+                async move {
+                    let body = load_body(req.take_payload()).await?;
+                    Ok::<_, Error>(Response::Ok().body(body))
+                }
            })
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send_body(data.clone()).await.unwrap();
    assert!(response.status().is_success());
@ -141,8 +138,7 @@ async fn test_h2_content_length() {
                future::ok::<_, ()>(Response::new(statuses[indx]))
            })
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let header = HeaderName::from_static("content-length");
    let value = HeaderValue::from_static("0");
@ -201,7 +197,7 @@ async fn test_h2_headers() {
            future::ok::<_, ()>(config.body(data.clone()))
        })
            .rustls(ssl_acceptor())
-    }).await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -239,8 +235,7 @@ async fn test_h2_body2() {
        HttpService::build()
            .h2(|_| future::ok::<_, ()>(Response::Ok().body(STR)))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -256,8 +251,7 @@ async fn test_h2_head_empty() {
        HttpService::build()
            .finish(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.shead("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -281,11 +275,10 @@ async fn test_h2_head_binary() {
    let mut srv = test_server(move || {
        HttpService::build()
            .h2(|_| {
-                ok::<_, ()>(Response::Ok().body(STR))
+                ok::<_, ()>(Response::Ok().content_length(STR.len() as u64).body(STR))
            })
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.shead("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -309,8 +302,7 @@ async fn test_h2_head_binary2() {
        HttpService::build()
            .h2(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.shead("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -335,8 +327,7 @@ async fn test_h2_body_length() {
                )
            })
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -359,8 +350,7 @@ async fn test_h2_body_chunked_explicit() {
                )
            })
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -388,8 +378,7 @@ async fn test_h2_response_http_error_handling() {
                }))
            }))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
@ -405,8 +394,7 @@ async fn test_h2_service_error() {
        HttpService::build()
            .h2(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
@ -422,8 +410,7 @@ async fn test_h1_service_error() {
        HttpService::build()
            .h1(|_| err::<Response, Error>(error::ErrorBadRequest("error")))
            .rustls(ssl_acceptor())
-    })
-    .await;
+    });

    let response = srv.sget("/").send().await.unwrap();
    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@ -6,8 +6,8 @@ use actix_http_test::test_server;
 use actix_rt::time::delay_for;
 use actix_service::fn_service;
 use bytes::Bytes;
-use futures_util::future::{self, err, ok, ready, FutureExt};
-use futures_util::stream::{once, StreamExt};
+use futures::future::{self, err, ok, ready, FutureExt};
+use futures::stream::{once, StreamExt};
 use regex::Regex;

 use actix_http::httpmessage::HttpMessage;
@ -27,8 +27,7 @@ async fn test_h1() {
                future::ok::<_, ()>(Response::Ok().finish())
            })
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -47,8 +46,7 @@ async fn test_h1_2() {
                future::ok::<_, ()>(Response::Ok().finish())
            })
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -67,8 +65,7 @@ async fn test_expect_continue() {
            }))
            .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@ -98,8 +95,7 @@ async fn test_expect_continue_h1() {
            }))
            .h1(fn_service(|_| future::ok::<_, ()>(Response::Ok().finish())))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test HTTP/1.1\r\nexpect: 100-continue\r\n\r\n");
@ -134,8 +130,7 @@ async fn test_chunked_payload() {
                    })
            }))
            .tcp()
-    })
-    .await;
+    });

    let returned_size = {
        let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
@ -177,8 +172,7 @@ async fn test_slow_request() {
            .client_timeout(100)
            .finish(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n");
@ -193,8 +187,7 @@ async fn test_http1_malformed_request() {
        HttpService::build()
            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test/tests/test HTTP1.1\r\n");
@ -209,8 +202,7 @@ async fn test_http1_keepalive() {
        HttpService::build()
            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
@ -231,8 +223,7 @@ async fn test_http1_keepalive_timeout() {
            .keep_alive(1)
            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
@ -252,8 +243,7 @@ async fn test_http1_keepalive_close() {
        HttpService::build()
            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ =
@ -273,8 +263,7 @@ async fn test_http10_keepalive_default_close() {
        HttpService::build()
            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.0\r\n\r\n");
@ -293,8 +282,7 @@ async fn test_http10_keepalive() {
        HttpService::build()
            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream
@ -321,8 +309,7 @@ async fn test_http1_keepalive_disabled() {
            .keep_alive(KeepAlive::Disabled)
            .h1(|_| future::ok::<_, ()>(Response::Ok().finish()))
            .tcp()
-    })
-    .await;
+    });

    let mut stream = net::TcpStream::connect(srv.addr()).unwrap();
    let _ = stream.write_all(b"GET /test/tests/test HTTP/1.1\r\n\r\n");
@ -357,8 +344,7 @@ async fn test_content_length() {
                future::ok::<_, ()>(Response::new(statuses[indx]))
            })
            .tcp()
-    })
-    .await;
+    });

    let header = HeaderName::from_static("content-length");
    let value = HeaderValue::from_static("0");
@ -411,7 +397,7 @@ async fn test_h1_headers() {
            }
            future::ok::<_, ()>(builder.body(data.clone()))
        }).tcp()
-    }).await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -449,8 +435,7 @@ async fn test_h1_body() {
        HttpService::build()
            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -466,8 +451,7 @@ async fn test_h1_head_empty() {
        HttpService::build()
            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .tcp()
-    })
-    .await;
+    });

    let response = srv.head("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -490,11 +474,10 @@ async fn test_h1_head_binary() {
    let mut srv = test_server(|| {
        HttpService::build()
            .h1(|_| {
-                ok::<_, ()>(Response::Ok().body(STR))
+                ok::<_, ()>(Response::Ok().content_length(STR.len() as u64).body(STR))
            })
            .tcp()
-    })
-    .await;
+    });

    let response = srv.head("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -518,8 +501,7 @@ async fn test_h1_head_binary2() {
        HttpService::build()
            .h1(|_| ok::<_, ()>(Response::Ok().body(STR)))
            .tcp()
-    })
-    .await;
+    });

    let response = srv.head("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -544,8 +526,7 @@ async fn test_h1_body_length() {
                )
            })
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -568,8 +549,7 @@ async fn test_h1_body_chunked_explicit() {
                )
            })
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -599,8 +579,7 @@ async fn test_h1_body_chunked_implicit() {
                ok::<_, ()>(Response::Ok().streaming(body))
            })
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
@ -632,8 +611,7 @@ async fn test_h1_response_http_error_handling() {
                )
            }))
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert_eq!(response.status(), http::StatusCode::INTERNAL_SERVER_ERROR);
@ -649,8 +627,7 @@ async fn test_h1_service_error() {
        HttpService::build()
            .h1(|_| future::err::<Response, Error>(error::ErrorBadRequest("error")))
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert_eq!(response.status(), http::StatusCode::BAD_REQUEST);
@ -670,8 +647,7 @@ async fn test_h1_on_connect() {
                future::ok::<_, ()>(Response::Ok().finish())
            })
            .tcp()
-    })
-    .await;
+    });

    let response = srv.get("/").send().await.unwrap();
    assert!(response.status().is_success());
--- a/actix-http/tests/test_ws.rs
+++ b/actix-http/tests/test_ws.rs
@ -1,5 +1,4 @@
 use std::cell::Cell;
-use std::future::Future;
 use std::marker::PhantomData;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
@ -10,9 +9,9 @@ use actix_http_test::test_server;
 use actix_service::{fn_factory, Service};
 use actix_utils::framed::Dispatcher;
 use bytes::Bytes;
-use futures_util::future;
-use futures_util::task::{Context, Poll};
-use futures_util::{SinkExt, StreamExt};
+use futures::future;
+use futures::task::{Context, Poll};
+use futures::{Future, SinkExt, StreamExt};

 struct WsService<T>(Arc<Mutex<(PhantomData<T>, Cell<bool>)>>);

@ -94,8 +93,7 @@ async fn test_simple() {
                .finish(|_| future::ok::<_, ()>(Response::NotFound()))
                .tcp()
        }
-    })
-    .await;
+    });

    // client service
    let mut framed = srv.ws().await.unwrap();
--- a/actix-identity/CHANGES.md
+++ b/actix-identity/CHANGES.md
@ -0,0 +1,13 @@
+# Changes
+
+## [0.2.1] - 2020-01-10
+
+* Fix panic with already borrowed: BorrowMutError #1263
+
+## [0.2.0] - 2019-12-20
+
+* Use actix-web 2.0
+
+## [0.1.0] - 2019-06-xx
+
+* Move identity middleware to separate crate
--- a/actix-identity/Cargo.toml
+++ b/actix-identity/Cargo.toml
@ -0,0 +1,29 @@
+[package]
+name = "actix-identity"
+version = "0.2.1"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
+description = "Identity service for actix web framework."
+readme = "README.md"
+keywords = ["http", "web", "framework", "async", "futures"]
+homepage = "https://actix.rs"
+repository = "https://github.com/actix/actix-web.git"
+documentation = "https://docs.rs/actix-identity/"
+license = "MIT/Apache-2.0"
+edition = "2018"
+
+[lib]
+name = "actix_identity"
+path = "src/lib.rs"
+
+[dependencies]
+actix-web = { version = "2.0.0", default-features = false, features = ["secure-cookies"] }
+actix-service = "1.0.2"
+futures = "0.3.1"
+serde = "1.0"
+serde_json = "1.0"
+time = "0.1.42"
+
+[dev-dependencies]
+actix-rt = "1.0.0"
+actix-http = "1.0.1"
+bytes = "0.5.3"
--- a/actix-identity/LICENSE-APACHE
+++ b/actix-identity/LICENSE-APACHE
@ -0,0 +1 @@
+../LICENSE-APACHE
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Yuki Okushi	d92d53a4f5	Merge pull request #1541 from JohnTitor/backport-files files: Bump up to 0.2.2	2020-05-27 00:37:29 +09:00
Yuki Okushi	55d79cc1b2	files: Bump up to 0.2.2	2020-05-26 17:22:16 +09:00
Yuki Okushi	a8117183bb	files: Minimize `futures` dependencies	2020-05-26 17:19:12 +09:00
Omid Rad	60dcfd1aff	Actix-files will always send SizedStream (#1496 ) * Fixes #1384 * There is no need to set no_chunking * Test content-length for static files * Update the tests * Add Changelog * Try to simply fix Windows test issues! Co-authored-by: Rob Ede <robjtede@icloud.com>	2020-05-26 17:18:47 +09:00
Yuki Okushi	7870165da2	Fix spelling error	2020-05-26 17:14:33 +09:00
Yuki Okushi	6560a2285f	Suppress warning	2020-05-26 17:13:35 +09:00
Yuki Okushi	12eccf40e1	Merge pull request #1539 from JohnTitor/framed-0.3.1 framed: Bump up to 0.3.1 with deprecation notice	2020-05-25 18:58:32 +09:00
Yuki Okushi	7a9c0f632d	framed: Bump up to 0.3.1 with deprecation notice	2020-05-25 18:20:55 +09:00
Yuki Okushi	7baa35a897	Merge pull request #1526 from actix/backport-gha 2.0: Tweak CI config	2020-05-21 15:04:28 +09:00
Yuki Okushi	ea0d748a5e	Remove Travis and AppVeyor config	2020-05-21 12:07:54 +09:00
Yuki Okushi	bc4f98321a	2.0: Tweak GHA config	2020-05-21 12:06:05 +09:00
Yuki Okushi	2ddbe2b15c	Merge pull request #1400 from JohnTitor/actions-2.0 [2.0 backport] Tweaks for GitHub Actions	2020-03-08 03:04:31 +09:00
Yuki Okushi	87378a7410	Demote lint level to warn	2020-03-08 02:23:55 +09:00
Yuki Okushi	ad0d809af6	Disable coverage for PRs	2020-03-08 02:03:08 +09:00
Yuki Okushi	7b00c16d44	Add some Actions workflows	2020-03-08 02:02:52 +09:00
Yuki Okushi	155a6db4cd	More ignore test causes timeout	2020-03-08 02:02:15 +09:00
Yuki Okushi	228e886986	Don't use cache in Windows CI (#1327 )	2020-03-08 02:01:59 +09:00
Yuki Okushi	4aa4b5f928	Tweak caches (#1319 ) * Try to use `cargo-cache` * Tweak issue template	2020-03-08 02:01:45 +09:00
cetra3	54ff97470e	Initial Issue template (#1311 ) * Initial Issue template * First round of changes for the bug report Co-authored-by: Yuki Okushi <huyuumi.dev@gmail.com>	2020-03-08 02:01:31 +09:00
Yuki Okushi	f02ad2913f	Fix vcpkg cache (#1312 )	2020-03-08 02:01:17 +09:00
Yuki Okushi	96b0dfeac3	Tweak actions (#1305 ) * Add benchmark action * Fix Windows build	2020-03-08 02:00:58 +09:00