BASELINE: Update Chromium to 67.0.3396.47

Change-Id: Idcb1341782e417561a2473eeecc82642dafda5b7 Reviewed-by: Michal Klocek <michal.klocek@qt.io>
author: Allan Sandfeld Jensen <allan.jensen@qt.io> 2018-05-15 10:20:33 +0200
committer: Allan Sandfeld Jensen <allan.jensen@qt.io> 2018-05-15 10:28:57 +0000
commit: d17ea114e5ef69ad5d5d7413280a13e6428098aa (patch)
tree: 2c01a75df69f30d27b1432467cfe7c1467a498da /chromium/net/spdy
parent: 8c5c43c7b138c9b4b0bf56d946e61d3bbc111bec (diff)
download: qtwebengine-chromium-d17ea114e5ef69ad5d5d7413280a13e6428098aa.tar.gz
44 files changed, 687 insertions, 368 deletions
diff --git a/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.cc b/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.cc
index 4069f33e7c9..e9145f54602 100644
--- a/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.cc
+++ b/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.cc
@@ -58,7 +58,8 @@ void BidirectionalStreamSpdyImpl::Start(
     const NetLogWithSource& net_log,
     bool /*send_request_headers_automatically*/,
     BidirectionalStreamImpl::Delegate* delegate,
-    std::unique_ptr<base::Timer> timer) {
+    std::unique_ptr<base::Timer> timer,
+    const NetworkTrafficAnnotationTag& traffic_annotation) {
   DCHECK(!stream_);
   DCHECK(timer);
 
@@ -75,13 +76,12 @@ void BidirectionalStreamSpdyImpl::Start(
 
   request_info_ = request_info;
 
-  // TODO(https://crbug.com/656607): Add proper annotation here.
   int rv = stream_request_.StartRequest(
       SPDY_BIDIRECTIONAL_STREAM, spdy_session_, request_info_->url,
       request_info_->priority, request_info_->socket_tag, net_log,
       base::Bind(&BidirectionalStreamSpdyImpl::OnStreamInitialized,
                  weak_factory_.GetWeakPtr()),
-      NO_TRAFFIC_ANNOTATION_BUG_656607);
+      traffic_annotation);
   if (rv != ERR_IO_PENDING)
     OnStreamInitialized(rv);
 }
diff --git a/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.h b/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.h
index c4c11ed5952..0962e78f4a5 100644
--- a/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.h
+++ b/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl.h
@@ -47,7 +47,8 @@ class NET_EXPORT_PRIVATE BidirectionalStreamSpdyImpl
              const NetLogWithSource& net_log,
              bool send_request_headers_automatically,
              BidirectionalStreamImpl::Delegate* delegate,
-             std::unique_ptr<base::Timer> timer) override;
+             std::unique_ptr<base::Timer> timer,
+             const NetworkTrafficAnnotationTag& traffic_annotation) override;
   void SendRequestHeaders() override;
   int ReadData(IOBuffer* buf, int buf_len) override;
   void SendvData(const std::vector<scoped_refptr<IOBuffer>>& buffers,
diff --git a/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl_unittest.cc b/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl_unittest.cc
index 76a50ac83c5..4a88949f296 100644
--- a/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl_unittest.cc
+++ b/chromium/net/spdy/chromium/bidirectional_stream_spdy_impl_unittest.cc
@@ -25,6 +25,7 @@
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -133,7 +134,8 @@ class TestDelegateBase : public BidirectionalStreamImpl::Delegate {
              const NetLogWithSource& net_log) {
     stream_->Start(request, net_log,
                    /*send_request_headers_automatically=*/false, this,
-                   std::make_unique<base::Timer>(false, false));
+                   std::make_unique<base::Timer>(false, false),
+                   TRAFFIC_ANNOTATION_FOR_TESTS);
     not_expect_callback_ = false;
   }
 
diff --git a/chromium/net/spdy/chromium/buffered_spdy_framer.cc b/chromium/net/spdy/chromium/buffered_spdy_framer.cc
index a797362361a..0b5e76db109 100644
--- a/chromium/net/spdy/chromium/buffered_spdy_framer.cc
+++ b/chromium/net/spdy/chromium/buffered_spdy_framer.cc
@@ -140,7 +140,11 @@ void BufferedSpdyFramer::OnSettings() {
   visitor_->OnSettings();
 }
 
-void BufferedSpdyFramer::OnSetting(SpdyKnownSettingsId id, uint32_t value) {
+void BufferedSpdyFramer::OnSettingOld(SpdyKnownSettingsId id, uint32_t value) {
+  visitor_->OnSetting(id, value);
+}
+
+void BufferedSpdyFramer::OnSetting(SpdySettingsId id, uint32_t value) {
   visitor_->OnSetting(id, value);
 }
 
diff --git a/chromium/net/spdy/chromium/buffered_spdy_framer.h b/chromium/net/spdy/chromium/buffered_spdy_framer.h
index 71ae7836626..e7cbc050754 100644
--- a/chromium/net/spdy/chromium/buffered_spdy_framer.h
+++ b/chromium/net/spdy/chromium/buffered_spdy_framer.h
@@ -70,9 +70,9 @@ class NET_EXPORT_PRIVATE BufferedSpdyFramerVisitorInterface {
   // Called when a SETTINGS frame is received.
   virtual void OnSettings() = 0;
 
-  // Called when an individual setting within a SETTINGS frame has been parsed
-  // and validated.
-  virtual void OnSetting(SpdyKnownSettingsId id, uint32_t value) = 0;
+  // Called when an individual setting within a SETTINGS frame has been parsed.
+  // Note that |id| may or may not be a SETTINGS ID defined in the HTTP/2 spec.
+  virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
 
   // Called when a SETTINGS frame is received with the ACK flag set.
   virtual void OnSettingsAck() = 0;
@@ -158,7 +158,8 @@ class NET_EXPORT_PRIVATE BufferedSpdyFramer
       SpdyStreamId stream_id) override;
   void OnHeaderFrameEnd(SpdyStreamId stream_id) override;
   void OnSettings() override;
-  void OnSetting(SpdyKnownSettingsId id, uint32_t value) override;
+  void OnSettingOld(SpdyKnownSettingsId id, uint32_t value) override;
+  void OnSetting(SpdySettingsId id, uint32_t value) override;
   void OnSettingsAck() override;
   void OnSettingsEnd() override;
   void OnPing(SpdyPingId unique_id, bool is_ack) override;
diff --git a/chromium/net/spdy/chromium/buffered_spdy_framer_unittest.cc b/chromium/net/spdy/chromium/buffered_spdy_framer_unittest.cc
index b9a983a8645..a35e4e19bf2 100644
--- a/chromium/net/spdy/chromium/buffered_spdy_framer_unittest.cc
+++ b/chromium/net/spdy/chromium/buffered_spdy_framer_unittest.cc
@@ -80,7 +80,7 @@ class TestBufferedSpdyVisitor : public BufferedSpdyFramerVisitorInterface {
 
   void OnSettingsEnd() override {}
 
-  void OnSetting(SpdyKnownSettingsId id, uint32_t value) override {
+  void OnSetting(SpdySettingsId id, uint32_t value) override {
     setting_count_++;
   }
 
diff --git a/chromium/net/spdy/chromium/spdy_http_stream.cc b/chromium/net/spdy/chromium/spdy_http_stream.cc
index df05b4fed71..c852d8b6203 100644
--- a/chromium/net/spdy/chromium/spdy_http_stream.cc
+++ b/chromium/net/spdy/chromium/spdy_http_stream.cc
@@ -23,6 +23,7 @@
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/spdy/chromium/spdy_http_utils.h"
+#include "net/spdy/chromium/spdy_log_util.h"
 #include "net/spdy/chromium/spdy_session.h"
 #include "net/spdy/core/spdy_header_block.h"
 #include "net/spdy/core/spdy_protocol.h"
@@ -92,13 +93,12 @@ int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
     }
   }
 
-  // TODO(https://crbug.com/656607): Add proper annotation here.
   int rv = stream_request_.StartRequest(
       SPDY_REQUEST_RESPONSE_STREAM, spdy_session_, request_info_->url, priority,
       request_info_->socket_tag, stream_net_log,
       base::BindOnce(&SpdyHttpStream::OnStreamCreated,
                      weak_factory_.GetWeakPtr(), std::move(callback)),
-      NO_TRAFFIC_ANNOTATION_BUG_656607);
+      NetworkTrafficAnnotationTag(request_info->traffic_annotation));
 
   if (rv == OK) {
     stream_ = stream_request_.ReleaseStream().get();
diff --git a/chromium/net/spdy/chromium/spdy_http_stream_unittest.cc b/chromium/net/spdy/chromium/spdy_http_stream_unittest.cc
index ecd3db54a53..f01654277b0 100644
--- a/chromium/net/spdy/chromium/spdy_http_stream_unittest.cc
+++ b/chromium/net/spdy/chromium/spdy_http_stream_unittest.cc
@@ -31,6 +31,7 @@
 #include "net/test/cert_test_util.h"
 #include "net/test/gtest_util.h"
 #include "net/test/test_data_directory.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -196,6 +197,8 @@ TEST_F(SpdyHttpStreamTest, SendRequest) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
@@ -252,6 +255,8 @@ TEST_F(SpdyHttpStreamTest, RequestInfoDestroyedBeforeRead) {
       std::make_unique<HttpRequestInfo>();
   request->method = "GET";
   request->url = url_;
+  request->traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
@@ -313,6 +318,8 @@ TEST_F(SpdyHttpStreamTest, LoadTimingTwoRequests) {
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = url_;
+  request1.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   TestCompletionCallback callback1;
   HttpResponseInfo response1;
   HttpRequestHeaders headers1;
@@ -323,6 +330,8 @@ TEST_F(SpdyHttpStreamTest, LoadTimingTwoRequests) {
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = url_;
+  request2.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   TestCompletionCallback callback2;
   HttpResponseInfo response2;
   HttpRequestHeaders headers2;
@@ -413,6 +422,8 @@ TEST_F(SpdyHttpStreamTest, SendChunkedPost) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
@@ -467,6 +478,8 @@ TEST_F(SpdyHttpStreamTest, SendChunkedPostLastEmpty) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
@@ -520,6 +533,8 @@ TEST_F(SpdyHttpStreamTest, ConnectionClosedDuringChunkedPost) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
@@ -590,6 +605,8 @@ TEST_F(SpdyHttpStreamTest, DelayedSendChunkedPost) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
@@ -685,6 +702,8 @@ TEST_F(SpdyHttpStreamTest, DelayedSendChunkedPostWithEmptyFinalDataFrame) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
@@ -769,6 +788,8 @@ TEST_F(SpdyHttpStreamTest, ChunkedPostWithEmptyPayload) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
@@ -833,6 +854,8 @@ TEST_F(SpdyHttpStreamTest, SpdyURLTest) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(full_url);
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
@@ -846,7 +869,7 @@ TEST_F(SpdyHttpStreamTest, SpdyURLTest) {
   EXPECT_THAT(http_stream->SendRequest(headers, &response, callback.callback()),
               IsError(ERR_IO_PENDING));
 
-  EXPECT_EQ(base_url, http_stream->stream()->GetUrlFromHeaders().spec());
+  EXPECT_EQ(base_url, http_stream->stream()->url().spec());
 
   callback.WaitForResult();
 
@@ -883,6 +906,8 @@ TEST_F(SpdyHttpStreamTest, DelayedSendChunkedPostWithWindowUpdate) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback(),
@@ -989,6 +1014,8 @@ TEST_F(SpdyHttpStreamTest, DataReadErrorSynchronous) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_data_stream;
 
   TestCompletionCallback callback;
@@ -1042,6 +1069,8 @@ TEST_F(SpdyHttpStreamTest, DataReadErrorAsynchronous) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   request.upload_data_stream = &upload_data_stream;
 
   TestCompletionCallback callback;
@@ -1079,6 +1108,8 @@ TEST_F(SpdyHttpStreamTest, RequestCallbackCancelsStream) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
+  request.traffic_annotation =
+      MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
   ChunkedUploadDataStream upload_stream(0);
   request.upload_data_stream = &upload_stream;
 
diff --git a/chromium/net/spdy/chromium/spdy_http_utils.cc b/chromium/net/spdy/chromium/spdy_http_utils.cc
index 0cb8c3a26cb..74356b35a4d 100644
--- a/chromium/net/spdy/chromium/spdy_http_utils.cc
+++ b/chromium/net/spdy/chromium/spdy_http_utils.cc
@@ -114,7 +114,7 @@ void CreateSpdyHeadersFromHttpRequestForWebSocket(
     const HttpRequestHeaders& request_headers,
     SpdyHeaderBlock* headers) {
   (*headers)[kHttp2MethodHeader] = "CONNECT";
-  (*headers)[kHttp2AuthorityHeader] = GetHostAndPort(url);
+  (*headers)[kHttp2AuthorityHeader] = GetHostAndOptionalPort(url);
   (*headers)[kHttp2SchemeHeader] = "https";
   (*headers)[kHttp2PathHeader] = url.PathForRequest();
   (*headers)[kHttp2ProtocolHeader] = "websocket";
diff --git a/chromium/net/spdy/chromium/spdy_log_util.cc b/chromium/net/spdy/chromium/spdy_log_util.cc
index 4ef8e06e0ca..b1d20b78f38 100644
--- a/chromium/net/spdy/chromium/spdy_log_util.cc
+++ b/chromium/net/spdy/chromium/spdy_log_util.cc
@@ -36,4 +36,20 @@ std::unique_ptr<base::ListValue> ElideSpdyHeaderBlockForNetLog(
   return headers_list;
 }
 
+std::unique_ptr<base::Value> SpdyHeaderBlockNetLogCallback(
+    const SpdyHeaderBlock* headers,
+    NetLogCaptureMode capture_mode) {
+  auto dict = std::make_unique<base::DictionaryValue>();
+  auto headers_dict = std::make_unique<base::DictionaryValue>();
+  for (SpdyHeaderBlock::const_iterator it = headers->begin();
+       it != headers->end(); ++it) {
+    headers_dict->SetKey(
+        it->first.as_string(),
+        base::Value(ElideHeaderValueForNetLog(
+            capture_mode, it->first.as_string(), it->second.as_string())));
+  }
+  dict->Set("headers", std::move(headers_dict));
+  return std::move(dict);
+}
+
 }  // namespace net
diff --git a/chromium/net/spdy/chromium/spdy_log_util.h b/chromium/net/spdy/chromium/spdy_log_util.h
index 86635eaf1ce..92b8bee398b 100644
--- a/chromium/net/spdy/chromium/spdy_log_util.h
+++ b/chromium/net/spdy/chromium/spdy_log_util.h
@@ -9,6 +9,8 @@
 
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
+#include "net/http/http_log_util.h"
+#include "net/log/net_log.h"
 #include "net/log/net_log_capture_mode.h"
 #include "net/spdy/core/spdy_header_block.h"
 #include "net/spdy/platform/api/spdy_string.h"
@@ -30,6 +32,11 @@ NET_EXPORT_PRIVATE std::unique_ptr<base::ListValue>
 ElideSpdyHeaderBlockForNetLog(const SpdyHeaderBlock& headers,
                               NetLogCaptureMode capture_mode);
 
+// Converts a SpdyHeaderBlock into NetLog event parameters.
+NET_EXPORT_PRIVATE std::unique_ptr<base::Value> SpdyHeaderBlockNetLogCallback(
+    const SpdyHeaderBlock* headers,
+    NetLogCaptureMode capture_mode);
+
 }  // namespace net
 
 #endif  // NET_SPDY_CHROMIUM_SPDY_LOG_UTIL_H_
diff --git a/chromium/net/spdy/chromium/spdy_network_transaction_unittest.cc b/chromium/net/spdy/chromium/spdy_network_transaction_unittest.cc
index 3fdf3e5198a..9d3202ac0ab 100644
--- a/chromium/net/spdy/chromium/spdy_network_transaction_unittest.cc
+++ b/chromium/net/spdy/chromium/spdy_network_transaction_unittest.cc
@@ -29,6 +29,7 @@
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_network_transaction.h"
+#include "net/http/http_response_info.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/log/net_log_event_type.h"
@@ -592,6 +593,43 @@ TEST_F(SpdyNetworkTransactionTest, Get) {
   EXPECT_EQ("hello!", out.response_data);
 }
 
+TEST_F(SpdyNetworkTransactionTest, SetPriority) {
+  for (bool set_priority_before_starting_transaction : {true, false}) {
+    SpdyTestUtil spdy_test_util;
+    SpdySerializedFrame req(
+        spdy_test_util.ConstructSpdyGet(nullptr, 0, 1, LOWEST));
+    MockWrite writes[] = {CreateMockWrite(req, 0)};
+
+    SpdySerializedFrame resp(
+        spdy_test_util.ConstructSpdyGetReply(nullptr, 0, 1));
+    SpdySerializedFrame body(spdy_test_util.ConstructSpdyDataFrame(1, true));
+    MockRead reads[] = {CreateMockRead(resp, 1), CreateMockRead(body, 2),
+                        MockRead(ASYNC, 0, 3)};
+
+    SequencedSocketData data(reads, arraysize(reads), writes,
+                             arraysize(writes));
+    NormalSpdyTransactionHelper helper(request_, HIGHEST, log_, nullptr);
+    helper.RunPreTestSetup();
+    helper.AddData(&data);
+
+    if (set_priority_before_starting_transaction) {
+      helper.trans()->SetPriority(LOWEST);
+      EXPECT_TRUE(helper.StartDefaultTest());
+    } else {
+      EXPECT_TRUE(helper.StartDefaultTest());
+      helper.trans()->SetPriority(LOWEST);
+    }
+
+    helper.FinishDefaultTest();
+    helper.VerifyDataConsumed();
+
+    TransactionHelperResult out = helper.output();
+    EXPECT_THAT(out.rv, IsOk());
+    EXPECT_EQ("HTTP/1.1 200", out.status_line);
+    EXPECT_EQ("hello!", out.response_data);
+  }
+}
+
 TEST_F(SpdyNetworkTransactionTest, GetAtEachPriority) {
   for (RequestPriority p = MINIMUM_PRIORITY; p <= MAXIMUM_PRIORITY;
        p = RequestPriority(p + 1)) {
@@ -4498,7 +4536,8 @@ TEST_F(SpdyNetworkTransactionTest, HTTP11RequiredRetry) {
 TEST_F(SpdyNetworkTransactionTest, HTTP11RequiredProxyRetry) {
   request_.method = "GET";
   auto session_deps = std::make_unique<SpdySessionDependencies>(
-      ProxyResolutionService::CreateFixedFromPacResult("HTTPS myproxy:70"));
+      ProxyResolutionService::CreateFixedFromPacResult(
+          "HTTPS myproxy:70", TRAFFIC_ANNOTATION_FOR_TESTS));
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
                                      std::move(session_deps));
@@ -4586,7 +4625,8 @@ TEST_F(SpdyNetworkTransactionTest, HTTP11RequiredProxyRetry) {
 // Test to make sure we can correctly connect through a proxy.
 TEST_F(SpdyNetworkTransactionTest, ProxyConnect) {
   auto session_deps = std::make_unique<SpdySessionDependencies>(
-      ProxyResolutionService::CreateFixedFromPacResult("PROXY myproxy:70"));
+      ProxyResolutionService::CreateFixedFromPacResult(
+          "PROXY myproxy:70", TRAFFIC_ANNOTATION_FOR_TESTS));
   NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
                                      std::move(session_deps));
   helper.RunPreTestSetup();
@@ -4610,10 +4650,9 @@ TEST_F(SpdyNetworkTransactionTest, ProxyConnect) {
       CreateMockRead(resp, 3), CreateMockRead(body, 4),
       MockRead(ASYNC, 0, 0, 5),
   };
-  auto data = std::make_unique<SequencedSocketData>(reads, arraysize(reads),
-                                                    writes, arraysize(writes));
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
-  helper.AddData(data.get());
+  helper.AddData(&data);
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request_, callback.callback(), log_);
@@ -4643,7 +4682,7 @@ TEST_F(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) {
   // that the session pool key used does is just "DIRECT".
   auto session_deps = std::make_unique<SpdySessionDependencies>(
       ProxyResolutionService::CreateFixedFromPacResult(
-          "DIRECT; PROXY myproxy:70"));
+          "DIRECT; PROXY myproxy:70", TRAFFIC_ANNOTATION_FOR_TESTS));
   // When setting up the first transaction, we store the SpdySessionPool so that
   // we can use the same pool in the second transaction.
   NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
@@ -4720,19 +4759,20 @@ TEST_F(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) {
       MockRead(ASYNC, 0, 5)  // EOF
   };
 
-  auto data_proxy = std::make_unique<SequencedSocketData>(
-      reads2, arraysize(reads2), writes2, arraysize(writes2));
+  SequencedSocketData data_proxy(reads2, arraysize(reads2), writes2,
+                                 arraysize(writes2));
 
   // Create another request to www.example.org, but this time through a proxy.
   request_.method = "GET";
   request_.url = GURL("https://www.example.org/foo.dat");
   auto session_deps_proxy = std::make_unique<SpdySessionDependencies>(
-      ProxyResolutionService::CreateFixedFromPacResult("PROXY myproxy:70"));
+      ProxyResolutionService::CreateFixedFromPacResult(
+          "PROXY myproxy:70", TRAFFIC_ANNOTATION_FOR_TESTS));
   NormalSpdyTransactionHelper helper_proxy(request_, DEFAULT_PRIORITY, log_,
                                            std::move(session_deps_proxy));
 
   helper_proxy.RunPreTestSetup();
-  helper_proxy.AddData(data_proxy.get());
+  helper_proxy.AddData(&data_proxy);
 
   HttpNetworkTransaction* trans_proxy = helper_proxy.trans();
   TestCompletionCallback callback_proxy;
@@ -6858,7 +6898,8 @@ TEST_F(SpdyNetworkTransactionTest, InsecureUrlCreatesSecureSpdySession) {
 
   // Need secure proxy so that insecure URL can use HTTP/2.
   auto session_deps = std::make_unique<SpdySessionDependencies>(
-      ProxyResolutionService::CreateFixedFromPacResult("HTTPS myproxy:70"));
+      ProxyResolutionService::CreateFixedFromPacResult(
+          "HTTPS myproxy:70", TRAFFIC_ANNOTATION_FOR_TESTS));
   NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
                                      std::move(session_deps));
 
@@ -7119,7 +7160,7 @@ TEST_F(SpdyNetworkTransactionTest, WebSocketOverHTTP2) {
 
   SpdyHeaderBlock websocket_request_headers;
   websocket_request_headers[kHttp2MethodHeader] = "CONNECT";
-  websocket_request_headers[kHttp2AuthorityHeader] = "www.example.org:443";
+  websocket_request_headers[kHttp2AuthorityHeader] = "www.example.org";
   websocket_request_headers[kHttp2SchemeHeader] = "https";
   websocket_request_headers[kHttp2PathHeader] = "/";
   websocket_request_headers[kHttp2ProtocolHeader] = "websocket";
@@ -7213,6 +7254,80 @@ TEST_F(SpdyNetworkTransactionTest, WebSocketOverHTTP2) {
   helper.VerifyDataConsumed();
 }
 
+TEST_F(SpdyNetworkTransactionTest, WebSocketNegotiatesHttp2) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("wss://www.example.org/");
+  request.traffic_annotation =
+      net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
+  EXPECT_TRUE(HostPortPair::FromURL(request_.url)
+                  .Equals(HostPortPair::FromURL(request.url)));
+  request.extra_headers.SetHeader("Connection", "Upgrade");
+  request.extra_headers.SetHeader("Upgrade", "websocket");
+  request.extra_headers.SetHeader("Origin", "http://www.example.org");
+  request.extra_headers.SetHeader("Sec-WebSocket-Version", "13");
+
+  NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_, nullptr);
+  helper.RunPreTestSetup();
+
+  StaticSocketDataProvider data(nullptr, 0, nullptr, 0);
+
+  auto ssl_provider = std::make_unique<SSLSocketDataProvider>(ASYNC, OK);
+  // Test that request has empty |alpn_protos|, that is, HTTP/2 is disabled.
+  ssl_provider->next_protos_expected_in_ssl_config = NextProtoVector{};
+  // Force socket to use HTTP/1.1, the default protocol without ALPN.
+  ssl_provider->next_proto = kProtoHTTP2;
+  ssl_provider->ssl_info.cert =
+      ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem");
+  helper.AddDataWithSSLSocketDataProvider(&data, std::move(ssl_provider));
+
+  HttpNetworkTransaction* trans = helper.trans();
+  TestWebSocketHandshakeStreamCreateHelper websocket_stream_create_helper;
+  trans->SetWebSocketHandshakeStreamCreateHelper(
+      &websocket_stream_create_helper);
+
+  TestCompletionCallback callback;
+  int rv = trans->Start(&request, callback.callback(), log_);
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
+  rv = callback.WaitForResult();
+  ASSERT_THAT(rv, IsError(ERR_NOT_IMPLEMENTED));
+
+  helper.VerifyDataConsumed();
+}
+
+// Plaintext WebSocket over HTTP/2 is not implemented, see
+// https://crbug.com/684681.
+TEST_F(SpdyNetworkTransactionTest, PlaintextWebSocketOverHttp2Proxy) {
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyConnect(
+      nullptr, 0, 1, LOWEST, HostPortPair("www.example.org", 80)));
+  MockWrite writes[] = {CreateMockWrite(req, 0)};
+
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
+  MockRead reads[] = {CreateMockRead(resp, 1), MockRead(ASYNC, 0, 2)};
+
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+
+  request_.url = GURL("ws://www.example.org/");
+  auto session_deps = std::make_unique<SpdySessionDependencies>(
+      ProxyResolutionService::CreateFixed("https://proxy:70",
+                                          TRAFFIC_ANNOTATION_FOR_TESTS));
+  NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
+                                     std::move(session_deps));
+  helper.RunPreTestSetup();
+  helper.AddData(&data);
+
+  HttpNetworkTransaction* trans = helper.trans();
+  TestWebSocketHandshakeStreamCreateHelper websocket_stream_create_helper;
+  trans->SetWebSocketHandshakeStreamCreateHelper(
+      &websocket_stream_create_helper);
+
+  EXPECT_TRUE(helper.StartDefaultTest());
+  helper.WaitForCallbackToComplete();
+  EXPECT_THAT(helper.output().rv, IsError(ERR_NOT_IMPLEMENTED));
+
+  helper.VerifyDataConsumed();
+}
+
 // Regression test for https://crbug.com/819101.  Open two identical plaintext
 // websocket requests over proxy.  The HttpStreamFactoryImpl::Job for the second
 // request should reuse the first connection.
@@ -7230,7 +7345,8 @@ TEST_F(SpdyNetworkTransactionTest, TwoWebSocketRequestsOverHttp2Proxy) {
 
   request_.url = GURL("ws://www.example.org/");
   auto session_deps = std::make_unique<SpdySessionDependencies>(
-      ProxyResolutionService::CreateFixed("https://proxy:70"));
+      ProxyResolutionService::CreateFixed("https://proxy:70",
+                                          TRAFFIC_ANNOTATION_FOR_TESTS));
   NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
                                      std::move(session_deps));
   helper.RunPreTestSetup();
@@ -7262,6 +7378,136 @@ TEST_F(SpdyNetworkTransactionTest, TwoWebSocketRequestsOverHttp2Proxy) {
   helper.VerifyDataConsumed();
 }
 
+TEST_F(SpdyNetworkTransactionTest, SecureWebSocketOverHttp2Proxy) {
+  SpdySerializedFrame connect_request(spdy_util_.ConstructSpdyConnect(
+      nullptr, 0, 1, LOWEST, HostPortPair("www.example.org", 443)));
+  const char kWebSocketRequest[] =
+      "GET / HTTP/1.1\r\n"
+      "Host: www.example.org\r\n"
+      "Connection: Upgrade\r\n"
+      "Upgrade: websocket\r\n"
+      "Origin: http://www.example.org\r\n"
+      "Sec-WebSocket-Version: 13\r\n"
+      "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+      "Sec-WebSocket-Extensions: permessage-deflate; "
+      "client_max_window_bits\r\n\r\n";
+  SpdySerializedFrame websocket_request(
+      spdy_util_.ConstructSpdyDataFrame(1, kWebSocketRequest, false));
+  MockWrite writes[] = {CreateMockWrite(connect_request, 0),
+                        CreateMockWrite(websocket_request, 2)};
+
+  SpdySerializedFrame connect_response(
+      spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
+  const char kWebSocketResponse[] =
+      "HTTP/1.1 101 Switching Protocols\r\n"
+      "Upgrade: websocket\r\n"
+      "Connection: Upgrade\r\n"
+      "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n\r\n";
+  SpdySerializedFrame websocket_response(
+      spdy_util_.ConstructSpdyDataFrame(1, kWebSocketResponse, false));
+  MockRead reads[] = {CreateMockRead(connect_response, 1),
+                      CreateMockRead(websocket_response, 3),
+                      MockRead(ASYNC, 0, 4)};
+
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+
+  request_.url = GURL("wss://www.example.org/");
+  request_.extra_headers.SetHeader("Connection", "Upgrade");
+  request_.extra_headers.SetHeader("Upgrade", "websocket");
+  request_.extra_headers.SetHeader("Origin", "http://www.example.org");
+  request_.extra_headers.SetHeader("Sec-WebSocket-Version", "13");
+  auto session_deps = std::make_unique<SpdySessionDependencies>(
+      ProxyResolutionService::CreateFixed("https://proxy:70",
+                                          TRAFFIC_ANNOTATION_FOR_TESTS));
+  NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
+                                     std::move(session_deps));
+  helper.RunPreTestSetup();
+  helper.AddData(&data);
+
+  // Add SSL data for the tunneled connection.
+  SSLSocketDataProvider ssl_provider(ASYNC, OK);
+  ssl_provider.ssl_info.cert =
+      ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
+  // A WebSocket request should not advertise HTTP/2 support.
+  ssl_provider.next_protos_expected_in_ssl_config = NextProtoVector{};
+  // This test uses WebSocket over HTTP/1.1.
+  ssl_provider.next_proto = kProtoHTTP11;
+  helper.session_deps()->socket_factory->AddSSLSocketDataProvider(
+      &ssl_provider);
+
+  HttpNetworkTransaction* trans = helper.trans();
+  TestWebSocketHandshakeStreamCreateHelper websocket_stream_create_helper;
+  trans->SetWebSocketHandshakeStreamCreateHelper(
+      &websocket_stream_create_helper);
+
+  EXPECT_TRUE(helper.StartDefaultTest());
+  helper.WaitForCallbackToComplete();
+  EXPECT_THAT(helper.output().rv, IsOk());
+  const HttpResponseInfo* response = trans->GetResponseInfo();
+  ASSERT_TRUE(response);
+  EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1_1,
+            response->connection_info);
+  EXPECT_TRUE(response->was_alpn_negotiated);
+  EXPECT_FALSE(response->was_fetched_via_spdy);
+  EXPECT_EQ(70, response->socket_address.port());
+  ASSERT_TRUE(response->headers);
+  EXPECT_EQ("HTTP/1.1 101 Switching Protocols",
+            response->headers->GetStatusLine());
+
+  base::RunLoop().RunUntilIdle();
+  helper.VerifyDataConsumed();
+}
+
+// Regression test for https://crbug.com/828865.
+TEST_F(SpdyNetworkTransactionTest,
+       SecureWebSocketOverHttp2ProxyNegotiatesHttp2) {
+  SpdySerializedFrame connect_request(spdy_util_.ConstructSpdyConnect(
+      nullptr, 0, 1, LOWEST, HostPortPair("www.example.org", 443)));
+  MockWrite writes[] = {CreateMockWrite(connect_request, 0)};
+  SpdySerializedFrame connect_response(
+      spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
+  MockRead reads[] = {CreateMockRead(connect_response, 1),
+                      MockRead(ASYNC, 0, 2)};
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+
+  request_.url = GURL("wss://www.example.org/");
+  request_.extra_headers.SetHeader("Connection", "Upgrade");
+  request_.extra_headers.SetHeader("Upgrade", "websocket");
+  request_.extra_headers.SetHeader("Origin", "http://www.example.org");
+  request_.extra_headers.SetHeader("Sec-WebSocket-Version", "13");
+  auto session_deps = std::make_unique<SpdySessionDependencies>(
+      ProxyResolutionService::CreateFixed("https://proxy:70",
+                                          TRAFFIC_ANNOTATION_FOR_TESTS));
+  NormalSpdyTransactionHelper helper(request_, DEFAULT_PRIORITY, log_,
+                                     std::move(session_deps));
+  helper.RunPreTestSetup();
+  helper.AddData(&data);
+
+  // Add SSL data for the tunneled connection.
+  SSLSocketDataProvider ssl_provider(ASYNC, OK);
+  ssl_provider.ssl_info.cert =
+      ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem");
+  // A WebSocket request should not advertise HTTP/2 support.
+  ssl_provider.next_protos_expected_in_ssl_config = NextProtoVector{};
+  // The server should not negotiate HTTP/2 over the tunnelled connection,
+  // but it must be handled gracefully if it does.
+  ssl_provider.next_proto = kProtoHTTP2;
+  helper.session_deps()->socket_factory->AddSSLSocketDataProvider(
+      &ssl_provider);
+
+  HttpNetworkTransaction* trans = helper.trans();
+  TestWebSocketHandshakeStreamCreateHelper websocket_stream_create_helper;
+  trans->SetWebSocketHandshakeStreamCreateHelper(
+      &websocket_stream_create_helper);
+
+  EXPECT_TRUE(helper.StartDefaultTest());
+  helper.WaitForCallbackToComplete();
+  EXPECT_THAT(helper.output().rv, IsError(ERR_NOT_IMPLEMENTED));
+
+  base::RunLoop().RunUntilIdle();
+  helper.VerifyDataConsumed();
+}
+
 #endif  // BUILDFLAG(ENABLE_WEBSOCKETS)
 
 }  // namespace net
diff --git a/chromium/net/spdy/chromium/spdy_session.cc b/chromium/net/spdy/chromium/spdy_session.cc
index 588ba6f56af..7a89b554a2d 100644
--- a/chromium/net/spdy/chromium/spdy_session.cc
+++ b/chromium/net/spdy/chromium/spdy_session.cc
@@ -25,8 +25,7 @@
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
-#include "crypto/ec_private_key.h"
-#include "crypto/ec_signature_creator.h"
+#include "net/base/url_util.h"
 #include "net/cert/asn1_util.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/ct_policy_status.h"
@@ -152,7 +151,7 @@ enum PushedStreamVaryResponseHeaderValues ParseVaryInPushedResponse(
   return kVaryHasNoAcceptEncoding;
 }
 
-bool IsSpdySettingAtDefaultInitialValue(SpdyKnownSettingsId setting_id,
+bool IsSpdySettingAtDefaultInitialValue(SpdySettingsId setting_id,
                                         uint32_t value) {
   switch (setting_id) {
     case SETTINGS_HEADER_TABLE_SIZE:
@@ -252,7 +251,7 @@ std::unique_ptr<base::Value> NetLogSpdySendSettingsCallback(
   auto settings_list = std::make_unique<base::ListValue>();
   for (SettingsMap::const_iterator it = settings->begin();
        it != settings->end(); ++it) {
-    const SpdyKnownSettingsId id = it->first;
+    const SpdySettingsId id = it->first;
     const uint32_t value = it->second;
     settings_list->AppendString(SpdyStringPrintf(
         "[id:%u (%s) value:%u]", id, SettingsIdToString(id).c_str(), value));
@@ -262,7 +261,7 @@ std::unique_ptr<base::Value> NetLogSpdySendSettingsCallback(
 }
 
 std::unique_ptr<base::Value> NetLogSpdyRecvSettingCallback(
-    SpdyKnownSettingsId id,
+    SpdySettingsId id,
     uint32_t value,
     NetLogCaptureMode /* capture_mode */) {
   auto dict = std::make_unique<base::DictionaryValue>();
@@ -626,10 +625,11 @@ int SpdyStreamRequest::StartRequest(
   DCHECK(!session_);
   DCHECK(!stream_);
   DCHECK(callback_.is_null());
+  DCHECK(url.is_valid()) << url.possibly_invalid_spec();
 
   type_ = type;
   session_ = session;
-  url_ = url;
+  url_ = SimplifyUrlForRequest(url);
   priority_ = priority;
   socket_tag_ = socket_tag;
   net_log_ = net_log;
@@ -1693,7 +1693,7 @@ void SpdySession::TryCreatePushStream(SpdyStreamId stream_id,
   }
 
   // Cross-origin push validation.
-  GURL associated_url(associated_it->second->GetUrlFromHeaders());
+  GURL associated_url(associated_it->second->url());
   if (associated_url.GetOrigin() != gurl.GetOrigin()) {
     if (is_trusted_proxy_) {
       if (!gurl.SchemeIs(url::kHttpScheme)) {
@@ -1737,11 +1737,32 @@ void SpdySession::TryCreatePushStream(SpdyStreamId stream_id,
                  stream_id),
       base::TimeDelta::FromSeconds(kPushedStreamLifetimeSeconds));
 
-  // TODO(https://crbug.com/656607): Add proper annotation here.
+  net::NetworkTrafficAnnotationTag traffic_annotation =
+      net::DefineNetworkTrafficAnnotation("spdy_push_stream", R"(
+        semantics {
+          sender: "Spdy Session"
+          description:
+            "When a web server needs to push a response to a client, an "
+            "incoming stream is created to reply the client with pushed "
+            "message instead of a message from the network."
+          trigger:
+            "A request by a server to push a response to the client."
+          data: "None."
+          destination: OTHER
+          destination_other:
+            "This stream is not used for sending data."
+        }
+        policy {
+          cookies_allowed: NO
+          setting: "This feature cannot be disabled."
+          policy_exception_justification: "Essential for navigation."
+        }
+    )");
+
   auto stream = std::make_unique<SpdyStream>(
       SPDY_PUSH_STREAM, GetWeakPtr(), gurl, request_priority,
       stream_initial_send_window_size_, stream_max_recv_window_size_, net_log_,
-      NO_TRAFFIC_ANNOTATION_BUG_656607);
+      traffic_annotation);
   stream->set_stream_id(stream_id);
 
   // Convert RequestPriority to a SpdyPriority to send in a PRIORITY frame.
@@ -2901,7 +2922,7 @@ void SpdySession::OnSettingsAck() {
     net_log_.AddEvent(NetLogEventType::HTTP2_SESSION_RECV_SETTINGS_ACK);
 }
 
-void SpdySession::OnSetting(SpdyKnownSettingsId id, uint32_t value) {
+void SpdySession::OnSetting(SpdySettingsId id, uint32_t value) {
   CHECK(in_io_loop_);
 
   HandleSetting(id, value);
diff --git a/chromium/net/spdy/chromium/spdy_session.h b/chromium/net/spdy/chromium/spdy_session.h
index 09fa118c041..54c16b443e3 100644
--- a/chromium/net/spdy/chromium/spdy_session.h
+++ b/chromium/net/spdy/chromium/spdy_session.h
@@ -53,6 +53,10 @@
 #include "url/gurl.h"
 #include "url/scheme_host_port.h"
 
+namespace crypto {
+class ECPrivateKey;
+}
+
 namespace net {
 
 namespace test {
@@ -782,7 +786,7 @@ class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface,
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override;
   void OnSettings() override;
   void OnSettingsAck() override;
-  void OnSetting(SpdyKnownSettingsId id, uint32_t value) override;
+  void OnSetting(SpdySettingsId id, uint32_t value) override;
   void OnSettingsEnd() override {}
   void OnWindowUpdate(SpdyStreamId stream_id, int delta_window_size) override;
   void OnPushPromise(SpdyStreamId stream_id,
diff --git a/chromium/net/spdy/chromium/spdy_session_pool.cc b/chromium/net/spdy/chromium/spdy_session_pool.cc
index c1134e66364..50894382ec8 100644
--- a/chromium/net/spdy/chromium/spdy_session_pool.cc
+++ b/chromium/net/spdy/chromium/spdy_session_pool.cc
@@ -19,6 +19,7 @@
 #include "net/base/trace_constants.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
+#include "net/http/http_stream_request.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source.h"
 #include "net/log/net_log_with_source.h"
@@ -149,17 +150,10 @@ base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
       net_log.AddEvent(
           NetLogEventType::HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION,
           it->second->net_log().source().ToEventParametersCallback());
-    } else {
-      if (!enable_ip_based_pooling) {
-        // Remove session from available sessions and from aliases, and remove
-        // key from the session's pooled alias set, so that a new session can be
-        // created with this |key|.
-        it->second->RemovePooledAlias(key);
-        UnmapKey(key);
-        RemoveAliases(key);
-        return base::WeakPtr<SpdySession>();
-      }
+      return it->second;
+    }
 
+    if (enable_ip_based_pooling) {
       UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
                                 FOUND_EXISTING_FROM_IP_POOL,
                                 SPDY_SESSION_GET_MAX);
@@ -167,8 +161,16 @@ base::WeakPtr<SpdySession> SpdySessionPool::FindAvailableSession(
           NetLogEventType::
               HTTP2_SESSION_POOL_FOUND_EXISTING_SESSION_FROM_IP_POOL,
           it->second->net_log().source().ToEventParametersCallback());
+      return it->second;
     }
-    return it->second;
+
+    // Remove session from available sessions and from aliases, and remove
+    // key from the session's pooled alias set, so that a new session can be
+    // created with this |key|.
+    it->second->RemovePooledAlias(key);
+    UnmapKey(key);
+    RemoveAliases(key);
+    return base::WeakPtr<SpdySession>();
   }
 
   if (!enable_ip_based_pooling)
@@ -403,7 +405,7 @@ void SpdySessionPool::OnNewSpdySessionReady(
     auto iter = spdy_session_request_map_.find(spdy_session_key);
     if (iter == spdy_session_request_map_.end())
       return;
-    HttpStreamFactoryImpl::Request* request = *iter->second.begin();
+    HttpStreamRequest* request = *iter->second.begin();
     request->Complete(was_alpn_negotiated, negotiated_protocol, using_spdy);
     RemoveRequestFromSpdySessionRequestMap(request);
     if (request->stream_type() == HttpStreamRequest::BIDIRECTIONAL_STREAM) {
@@ -446,7 +448,7 @@ void SpdySessionPool::ResumePendingRequests(
 
 void SpdySessionPool::AddRequestToSpdySessionRequestMap(
     const SpdySessionKey& spdy_session_key,
-    HttpStreamFactoryImpl::Request* request) {
+    HttpStreamRequest* request) {
   if (request->HasSpdySessionKey())
     return;
   RequestSet& request_set = spdy_session_request_map_[spdy_session_key];
@@ -456,7 +458,7 @@ void SpdySessionPool::AddRequestToSpdySessionRequestMap(
 }
 
 void SpdySessionPool::RemoveRequestFromSpdySessionRequestMap(
-    HttpStreamFactoryImpl::Request* request) {
+    HttpStreamRequest* request) {
   if (!request->HasSpdySessionKey())
     return;
   const SpdySessionKey& spdy_session_key = request->GetSpdySessionKey();
diff --git a/chromium/net/spdy/chromium/spdy_session_pool.h b/chromium/net/spdy/chromium/spdy_session_pool.h
index 8de7365a172..84c185c7863 100644
--- a/chromium/net/spdy/chromium/spdy_session_pool.h
+++ b/chromium/net/spdy/chromium/spdy_session_pool.h
@@ -23,8 +23,8 @@
 #include "net/base/network_change_notifier.h"
 #include "net/base/proxy_server.h"
 #include "net/cert/cert_database.h"
-#include "net/http/http_stream_factory_impl_request.h"
 #include "net/proxy_resolution/proxy_config.h"
+#include "net/quic/core/quic_versions.h"
 #include "net/spdy/chromium/http2_push_promise_index.h"
 #include "net/spdy/chromium/server_push_delegate.h"
 #include "net/spdy/chromium/spdy_session_key.h"
@@ -43,6 +43,7 @@ namespace net {
 class ClientSocketHandle;
 class HostResolver;
 class HttpServerProperties;
+class HttpStreamRequest;
 class NetLogWithSource;
 class SpdySession;
 class TransportSecurityState;
@@ -185,19 +186,17 @@ class NET_EXPORT SpdySessionPool
 
   // Adds |request| to |spdy_session_request_map_| under |spdy_session_key| Key.
   // Sets |spdy_session_key| as |request|'s SpdySessionKey.
-  void AddRequestToSpdySessionRequestMap(
-      const SpdySessionKey& spdy_session_key,
-      HttpStreamFactoryImpl::Request* request);
+  void AddRequestToSpdySessionRequestMap(const SpdySessionKey& spdy_session_key,
+                                         HttpStreamRequest* request);
 
   // Removes |request| from |spdy_session_request_map_|. No-op if |request| does
   // not have a SpdySessionKey.
-  void RemoveRequestFromSpdySessionRequestMap(
-      HttpStreamFactoryImpl::Request* request);
+  void RemoveRequestFromSpdySessionRequestMap(HttpStreamRequest* request);
 
  private:
   friend class SpdySessionPoolPeer;  // For testing.
 
-  typedef std::set<HttpStreamFactoryImpl::Request*> RequestSet;
+  typedef std::set<HttpStreamRequest*> RequestSet;
   typedef std::map<SpdySessionKey, RequestSet> SpdySessionRequestMap;
   typedef std::set<SpdySession*> SessionSet;
   typedef std::vector<base::WeakPtr<SpdySession> > WeakSessionList;
diff --git a/chromium/net/spdy/chromium/spdy_session_pool_unittest.cc b/chromium/net/spdy/chromium/spdy_session_pool_unittest.cc
index 870052ba649..3f35d1e59a2 100644
--- a/chromium/net/spdy/chromium/spdy_session_pool_unittest.cc
+++ b/chromium/net/spdy/chromium/spdy_session_pool_unittest.cc
@@ -178,13 +178,12 @@ TEST_F(SpdySessionPoolTest, CloseCurrentIdleSessions) {
   CreateNetworkSession();
 
   // Set up session 1
-  const SpdyString kTestHost1("www.example.org");
-  HostPortPair test_host_port_pair1(kTestHost1, 80);
+  const GURL url1("https://www.example.org");
+  HostPortPair test_host_port_pair1(HostPortPair::FromURL(url1));
   SpdySessionKey key1(test_host_port_pair1, ProxyServer::Direct(),
                       PRIVACY_MODE_DISABLED, SocketTag());
   base::WeakPtr<SpdySession> session1 =
       CreateSpdySession(http_session_.get(), key1, NetLogWithSource());
-  GURL url1(kTestHost1);
   base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session1, url1, MEDIUM, NetLogWithSource());
   ASSERT_TRUE(spdy_stream1);
@@ -193,13 +192,12 @@ TEST_F(SpdySessionPoolTest, CloseCurrentIdleSessions) {
   StaticSocketDataProvider data2(reads, arraysize(reads), nullptr, 0);
   data2.set_connect_data(connect_data);
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
-  const SpdyString kTestHost2("mail.example.org");
-  HostPortPair test_host_port_pair2(kTestHost2, 80);
+  const GURL url2("https://mail.example.org");
+  HostPortPair test_host_port_pair2(HostPortPair::FromURL(url2));
   SpdySessionKey key2(test_host_port_pair2, ProxyServer::Direct(),
                       PRIVACY_MODE_DISABLED, SocketTag());
   base::WeakPtr<SpdySession> session2 =
       CreateSpdySession(http_session_.get(), key2, NetLogWithSource());
-  GURL url2(kTestHost2);
   base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session2, url2, MEDIUM, NetLogWithSource());
   ASSERT_TRUE(spdy_stream2);
@@ -208,13 +206,12 @@ TEST_F(SpdySessionPoolTest, CloseCurrentIdleSessions) {
   StaticSocketDataProvider data3(reads, arraysize(reads), nullptr, 0);
   data3.set_connect_data(connect_data);
   session_deps_.socket_factory->AddSocketDataProvider(&data3);
-  const SpdyString kTestHost3("mail.example.com");
-  HostPortPair test_host_port_pair3(kTestHost3, 80);
+  const GURL url3("https://mail.example.com");
+  HostPortPair test_host_port_pair3(HostPortPair::FromURL(url3));
   SpdySessionKey key3(test_host_port_pair3, ProxyServer::Direct(),
                       PRIVACY_MODE_DISABLED, SocketTag());
   base::WeakPtr<SpdySession> session3 =
       CreateSpdySession(http_session_.get(), key3, NetLogWithSource());
-  GURL url3(kTestHost3);
   base::WeakPtr<SpdyStream> spdy_stream3 = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session3, url3, MEDIUM, NetLogWithSource());
   ASSERT_TRUE(spdy_stream3);
@@ -347,7 +344,7 @@ void SpdySessionPoolTest::RunIPPoolingTest(
     SpdySessionKey key;
     AddressList addresses;
   } test_hosts[] = {
-      {"http:://www.example.org", "www.example.org",
+      {"http://www.example.org", "www.example.org",
        "192.0.2.33,192.168.0.1,192.168.0.5"},
       {"http://mail.example.org", "mail.example.org",
        "192.168.0.2,192.168.0.3,192.168.0.5,192.0.2.33"},
diff --git a/chromium/net/spdy/chromium/spdy_session_unittest.cc b/chromium/net/spdy/chromium/spdy_session_unittest.cc
index bc40c21675b..37d53b40cd7 100644
--- a/chromium/net/spdy/chromium/spdy_session_unittest.cc
+++ b/chromium/net/spdy/chromium/spdy_session_unittest.cc
@@ -52,6 +52,7 @@
 using net::test::IsError;
 using net::test::IsOk;
 using net::test::TestServerPushDelegate;
+using testing::_;
 
 namespace net {
 
@@ -84,7 +85,10 @@ base::TimeTicks InstantaneousReads() {
 
 class MockRequireCTDelegate : public TransportSecurityState::RequireCTDelegate {
  public:
-  MOCK_METHOD1(IsCTRequiredForHost, CTRequirementLevel(const SpdyString& host));
+  MOCK_METHOD3(IsCTRequiredForHost,
+               CTRequirementLevel(const std::string& host,
+                                  const X509Certificate* chain,
+                                  const HashValueVector& hashes));
 };
 
 }  // namespace
@@ -1927,12 +1931,11 @@ TEST_F(SpdySessionTest, WaitingForWrongPing) {
 TEST_F(SpdySessionTest, OnSettings) {
   session_deps_.host_resolver->set_synchronous_mode(true);
 
-  const SpdyKnownSettingsId kSpdyKnownSettingsId =
-      SETTINGS_MAX_CONCURRENT_STREAMS;
+  const SpdySettingsId kSpdySettingsId = SETTINGS_MAX_CONCURRENT_STREAMS;
 
   SettingsMap new_settings;
   const uint32_t max_concurrent_streams = kInitialMaxConcurrentStreams + 1;
-  new_settings[kSpdyKnownSettingsId] = max_concurrent_streams;
+  new_settings[kSpdySettingsId] = max_concurrent_streams;
   SpdySerializedFrame settings_frame(
       spdy_util_.ConstructSpdySettings(new_settings));
   MockRead reads[] = {
@@ -2726,10 +2729,9 @@ TEST_F(SpdySessionTest, CloseTwoStalledCreateStream) {
   // TODO(rtenneti): Define a helper class/methods and move the common code in
   // this file.
   SettingsMap new_settings;
-  const SpdyKnownSettingsId kSpdyKnownSettingsId1 =
-      SETTINGS_MAX_CONCURRENT_STREAMS;
+  const SpdySettingsId kSpdySettingsId1 = SETTINGS_MAX_CONCURRENT_STREAMS;
   const uint32_t max_concurrent_streams = 1;
-  new_settings[kSpdyKnownSettingsId1] = max_concurrent_streams;
+  new_settings[kSpdySettingsId1] = max_concurrent_streams;
 
   SpdySerializedFrame settings_ack(spdy_util_.ConstructSpdySettingsAck());
   SpdySerializedFrame req1(spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST));
@@ -4477,7 +4479,7 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   stall_function.Run(stream.get());
 
@@ -4614,7 +4616,7 @@ TEST_F(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequestHeaders(std::move(headers1),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream1->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream1->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, stream1->stream_id());
@@ -4624,7 +4626,7 @@ TEST_F(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequestHeaders(std::move(headers2),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream2->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream2->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3u, stream2->stream_id());
@@ -4718,7 +4720,7 @@ TEST_F(SpdySessionTest, ResumeSessionWithStalledStream) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequestHeaders(std::move(headers1),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream1->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream1->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, stream1->stream_id());
@@ -4728,7 +4730,7 @@ TEST_F(SpdySessionTest, ResumeSessionWithStalledStream) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequestHeaders(std::move(headers2),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream2->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream2->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3u, stream2->stream_id());
@@ -4870,7 +4872,7 @@ TEST_F(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequestHeaders(std::move(headers1),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream1->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream1->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, stream1->stream_id());
@@ -4880,7 +4882,7 @@ TEST_F(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequestHeaders(std::move(headers2),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream2->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream2->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3u, stream2->stream_id());
@@ -4890,7 +4892,7 @@ TEST_F(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream3->SendRequestHeaders(std::move(headers3),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream3->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream3->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(5u, stream3->stream_id());
@@ -4995,7 +4997,7 @@ TEST_F(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream1->SendRequestHeaders(std::move(headers1),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream1->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream1->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1u, stream1->stream_id());
@@ -5005,7 +5007,7 @@ TEST_F(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING, stream2->SendRequestHeaders(std::move(headers2),
                                                         MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream2->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kDefaultUrl, stream2->url().spec());
 
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3u, stream2->stream_id());
@@ -6024,15 +6026,15 @@ TEST_F(SendInitialSettingsOnNewSpdySessionTest, OverwriteValues) {
 // Unknown parameters should still be sent to the server.
 TEST_F(SendInitialSettingsOnNewSpdySessionTest, UnknownSettings) {
   // The following parameters are not defined in the HTTP/2 specification.
-  session_deps_.http2_settings[static_cast<SpdyKnownSettingsId>(7)] = 1234;
-  session_deps_.http2_settings[static_cast<SpdyKnownSettingsId>(25)] = 5678;
+  session_deps_.http2_settings[7] = 1234;
+  session_deps_.http2_settings[25] = 5678;
 
   SettingsMap expected_settings;
   expected_settings[SETTINGS_HEADER_TABLE_SIZE] = kSpdyMaxHeaderTableSize;
   expected_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
       kSpdyMaxConcurrentPushedStreams;
-  expected_settings[static_cast<SpdyKnownSettingsId>(7)] = 1234;
-  expected_settings[static_cast<SpdyKnownSettingsId>(25)] = 5678;
+  expected_settings[7] = 1234;
+  expected_settings[25] = 5678;
   RunInitialSettingsTest(expected_settings);
 }
 
@@ -6555,9 +6557,10 @@ TEST(CanPoolTest, CanNotPoolWithBadCTWhenCTRequired) {
       ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS;
 
   MockRequireCTDelegate require_ct_delegate;
-  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("www.example.org"))
+  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("www.example.org", _, _))
       .WillRepeatedly(Return(CTRequirementLevel::NOT_REQUIRED));
-  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("mail.example.org"))
+  EXPECT_CALL(require_ct_delegate,
+              IsCTRequiredForHost("mail.example.org", _, _))
       .WillRepeatedly(Return(CTRequirementLevel::REQUIRED));
 
   TransportSecurityState tss;
@@ -6581,9 +6584,10 @@ TEST(CanPoolTest, CanPoolWithBadCTWhenCTNotRequired) {
       ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS;
 
   MockRequireCTDelegate require_ct_delegate;
-  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("www.example.org"))
+  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("www.example.org", _, _))
       .WillRepeatedly(Return(CTRequirementLevel::NOT_REQUIRED));
-  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("mail.example.org"))
+  EXPECT_CALL(require_ct_delegate,
+              IsCTRequiredForHost("mail.example.org", _, _))
       .WillRepeatedly(Return(CTRequirementLevel::NOT_REQUIRED));
 
   TransportSecurityState tss;
@@ -6607,9 +6611,10 @@ TEST(CanPoolTest, CanPoolWithGoodCTWhenCTRequired) {
       ct::CTPolicyCompliance::CT_POLICY_COMPLIES_VIA_SCTS;
 
   MockRequireCTDelegate require_ct_delegate;
-  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("www.example.org"))
+  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("www.example.org", _, _))
       .WillRepeatedly(Return(CTRequirementLevel::NOT_REQUIRED));
-  EXPECT_CALL(require_ct_delegate, IsCTRequiredForHost("mail.example.org"))
+  EXPECT_CALL(require_ct_delegate,
+              IsCTRequiredForHost("mail.example.org", _, _))
       .WillRepeatedly(Return(CTRequirementLevel::REQUIRED));
 
   TransportSecurityState tss;
diff --git a/chromium/net/spdy/chromium/spdy_stream.cc b/chromium/net/spdy/chromium/spdy_stream.cc
index 5c38ee45f64..dee8a868ff5 100644
--- a/chromium/net/spdy/chromium/spdy_stream.cc
+++ b/chromium/net/spdy/chromium/spdy_stream.cc
@@ -392,9 +392,13 @@ void SpdyStream::OnHeadersReceived(const SpdyHeaderBlock& response_headers,
           return;
         }
 
-        // Ignore informational headers.
+        // Ignore informational headers like 103 Early Hints.
         // TODO(bnc): Add support for 103 Early Hints, https://crbug.com/671310.
-        if (status / 100 == 1) {
+        // However, do not ignore 101 Switching Protocols, because broken
+        // servers might send this as a response to a WebSocket request,
+        // in which case it needs to pass through so that the WebSocket layer
+        // can signal an error.
+        if (status / 100 == 1 && status != 101) {
           return;
         }
       }
@@ -473,7 +477,6 @@ void SpdyStream::OnPushPromiseHeadersReceived(SpdyHeaderBlock headers,
   io_state_ = STATE_RESERVED_REMOTE;
   request_headers_ = std::move(headers);
   request_headers_valid_ = true;
-  url_from_header_block_ = std::move(url);
 }
 
 void SpdyStream::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) {
@@ -706,7 +709,6 @@ int SpdyStream::SendRequestHeaders(SpdyHeaderBlock request_headers,
   CHECK_EQ(io_state_, STATE_IDLE);
   request_headers_ = std::move(request_headers);
   request_headers_valid_ = true;
-  url_from_header_block_ = GetUrlFromHeaderBlock(request_headers_);
   pending_send_status_ = send_status;
   session_->EnqueueStreamWrite(
       GetWeakPtr(), SpdyFrameType::HEADERS,
@@ -731,6 +733,12 @@ bool SpdyStream::GetSSLInfo(SSLInfo* ssl_info) const {
   return session_->GetSSLInfo(ssl_info);
 }
 
+Error SpdyStream::GetTokenBindingSignature(crypto::ECPrivateKey* key,
+                                           TokenBindingType tb_type,
+                                           std::vector<uint8_t>* out) const {
+  return session_->GetTokenBindingSignature(key, tb_type, out);
+}
+
 bool SpdyStream::WasAlpnNegotiated() const {
   return session_->WasAlpnNegotiated();
 }
@@ -801,7 +809,6 @@ size_t SpdyStream::EstimateMemoryUsage() const {
   // once scoped_refptr support is in.
   return SpdyEstimateMemoryUsage(url_) +
          SpdyEstimateMemoryUsage(request_headers_) +
-         SpdyEstimateMemoryUsage(url_from_header_block_) +
          SpdyEstimateMemoryUsage(pending_recv_data_) +
          SpdyEstimateMemoryUsage(response_headers_);
 }
diff --git a/chromium/net/spdy/chromium/spdy_stream.h b/chromium/net/spdy/chromium/spdy_stream.h
index a47deebc30a..8095dc2c305 100644
--- a/chromium/net/spdy/chromium/spdy_stream.h
+++ b/chromium/net/spdy/chromium/spdy_stream.h
@@ -28,9 +28,14 @@
 #include "net/spdy/core/spdy_protocol.h"
 #include "net/spdy/platform/api/spdy_string.h"
 #include "net/ssl/ssl_client_cert_type.h"
+#include "net/ssl/token_binding.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 #include "url/gurl.h"
 
+namespace crypto {
+class ECPrivateKey;
+}
+
 namespace net {
 
 class IPEndPoint;
@@ -329,6 +334,13 @@ class NET_EXPORT_PRIVATE SpdyStream {
   // Fills SSL info in |ssl_info| and returns true when SSL is in use.
   bool GetSSLInfo(SSLInfo* ssl_info) const;
 
+  // Generates the signature used in Token Binding using |*key| and for a Token
+  // Binding of type |tb_type|, putting the signature in |*out|. Returns OK or
+  // ERR_FAILED.
+  Error GetTokenBindingSignature(crypto::ECPrivateKey* key,
+                                 TokenBindingType tb_type,
+                                 std::vector<uint8_t>* out) const;
+
   // Returns true if ALPN was negotiated for the underlying socket.
   bool WasAlpnNegotiated() const;
 
@@ -379,10 +391,6 @@ class NET_EXPORT_PRIVATE SpdyStream {
 
   const SpdyHeaderBlock& request_headers() { return request_headers_; }
 
-  // Get the URL from the appropriate stream headers, or the empty
-  // GURL() if it is unknown.
-  const GURL& GetUrlFromHeaders() const { return url_from_header_block_; }
-
   // Returns the estimate of dynamically allocated memory in bytes.
   size_t EstimateMemoryUsage() const;
 
@@ -484,9 +492,6 @@ class NET_EXPORT_PRIVATE SpdyStream {
   bool request_headers_valid_;
   SpdyHeaderBlock request_headers_;
 
-  // The URL from the request headers.
-  GURL url_from_header_block_;
-
   // Data waiting to be sent, and the close state of the local endpoint
   // after the data is fully written.
   scoped_refptr<DrainableIOBuffer> pending_send_data_;
diff --git a/chromium/net/spdy/chromium/spdy_stream_unittest.cc b/chromium/net/spdy/chromium/spdy_stream_unittest.cc
index dfdba6a9a1b..bc1ea24cbb5 100644
--- a/chromium/net/spdy/chromium/spdy_stream_unittest.cc
+++ b/chromium/net/spdy/chromium/spdy_stream_unittest.cc
@@ -192,17 +192,15 @@ TEST_F(SpdyStreamTest, SendDataAfterOpen) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
@@ -270,17 +268,15 @@ TEST_F(SpdyStreamTest, Trailers) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateWithTrailers delegate(stream, kPostBodyStringPiece);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
@@ -339,17 +335,15 @@ TEST_F(SpdyStreamTest, PushedStream) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_THAT(
       stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND),
       IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   data.RunUntilPaused();
 
@@ -372,7 +366,7 @@ TEST_F(SpdyStreamTest, PushedStream) {
                                        &push_stream, NetLogWithSource()),
               IsOk());
   ASSERT_TRUE(push_stream);
-  EXPECT_EQ(kPushUrl, push_stream->GetUrlFromHeaders().spec());
+  EXPECT_EQ(kPushUrl, push_stream->url().spec());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(push_stream->GetLoadTimingInfo(&load_timing_info));
@@ -430,17 +424,15 @@ TEST_F(SpdyStreamTest, StreamError) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session, url_, LOWEST, log.bound());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
@@ -501,18 +493,16 @@ TEST_F(SpdyStreamTest, SendLargeDataAfterOpenRequestResponse) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   SpdyString body_data(3 * kMaxSpdyFrameChunkSize, 'x');
   StreamDelegateWithBody delegate(stream, body_data);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
@@ -554,18 +544,16 @@ TEST_F(SpdyStreamTest, SendLargeDataAfterOpenBidirectional) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   SpdyString body_data(3 * kMaxSpdyFrameChunkSize, 'x');
   StreamDelegateSendImmediate delegate(stream, body_data);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 
@@ -604,17 +592,15 @@ TEST_F(SpdyStreamTest, UpperCaseHeaders) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_THAT(
       stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND),
       IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
@@ -664,17 +650,15 @@ TEST_F(SpdyStreamTest, UpperCaseHeadersOnPush) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_THAT(
       stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND),
       IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   data.RunUntilPaused();
 
@@ -721,16 +705,14 @@ TEST_F(SpdyStreamTest, HeadersMustHaveStatus) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
@@ -789,17 +771,15 @@ TEST_F(SpdyStreamTest, HeadersMustHaveStatusOnPushedStream) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_THAT(
       stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND),
       IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsOk());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(kHttp2StatusHeader));
@@ -841,16 +821,14 @@ TEST_F(SpdyStreamTest, HeadersMustPreceedData) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
@@ -897,17 +875,15 @@ TEST_F(SpdyStreamTest, HeadersMustPreceedDataOnPushedStream) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_THAT(
       stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND),
       IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsOk());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(kHttp2StatusHeader));
@@ -962,16 +938,14 @@ TEST_F(SpdyStreamTest, TrailersMustNotFollowTrailers) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
@@ -1021,16 +995,14 @@ TEST_F(SpdyStreamTest, DataMustNotFollowTrailers) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
@@ -1074,16 +1046,14 @@ TEST_F(SpdyStreamTest, InformationalHeaders) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsOk());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(kHttp2StatusHeader));
@@ -1126,16 +1096,14 @@ TEST_F(SpdyStreamTest, StatusMustBeNumber) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
@@ -1180,16 +1148,14 @@ TEST_F(SpdyStreamTest, StatusCannotHaveExtraText) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
@@ -1232,16 +1198,14 @@ TEST_F(SpdyStreamTest, StatusMustBePresent) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
@@ -1284,6 +1248,8 @@ TEST_F(SpdyStreamTest, IncreaseSendWindowSizeOverflow) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session, url_, LOWEST, log.bound());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
+
   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
   stream->SetDelegate(&delegate);
 
@@ -1291,7 +1257,6 @@ TEST_F(SpdyStreamTest, IncreaseSendWindowSizeOverflow) {
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   data.RunUntilPaused();
 
@@ -1369,18 +1334,17 @@ void SpdyStreamTest::RunResumeAfterUnstallRequestResponseTest(
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateWithBody delegate(stream, kPostBodyStringPiece);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   StallStream(stream);
 
@@ -1446,17 +1410,15 @@ void SpdyStreamTest::RunResumeAfterUnstallBidirectionalTest(
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   data.RunUntilPaused();
 
@@ -1525,17 +1487,15 @@ TEST_F(SpdyStreamTest, ReceivedBytes) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_REQUEST_RESPONSE_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl));
   EXPECT_THAT(
       stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND),
       IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   int64_t reply_frame_len = reply.size();
   int64_t data_header_len = kDataFrameMinimumSize;
@@ -1598,17 +1558,15 @@ TEST_F(SpdyStreamTest, DataOnHalfClosedRemoveStream) {
   base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
       SPDY_BIDIRECTIONAL_STREAM, session, url_, LOWEST, NetLogWithSource());
   ASSERT_TRUE(stream);
+  EXPECT_EQ(kDefaultUrl, stream->url().spec());
 
   StreamDelegateDoNothing delegate(stream);
   stream->SetDelegate(&delegate);
 
-  EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty());
-
   SpdyHeaderBlock headers(
       spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kPostBodyLength));
   EXPECT_THAT(stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND),
               IsError(ERR_IO_PENDING));
-  EXPECT_EQ(kDefaultUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
diff --git a/chromium/net/spdy/chromium/spdy_test_util_common.cc b/chromium/net/spdy/chromium/spdy_test_util_common.cc
index ff573aba4b5..ed115348ad3 100644
--- a/chromium/net/spdy/chromium/spdy_test_util_common.cc
+++ b/chromium/net/spdy/chromium/spdy_test_util_common.cc
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <utility>
 
+#include "base/base64.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ -99,8 +100,7 @@ void AppendToHeaderBlock(const char* const extra_headers[],
   for (int i = 0; i < extra_header_count; i++) {
     SpdyStringPiece key(extra_headers[i * 2]);
     SpdyStringPiece value(extra_headers[i * 2 + 1]);
-    DCHECK(!key.empty()) << "Empty header key.";
-    DCHECK(!value.empty()) << "Empty header value.";
+    DCHECK(!key.empty()) << "Header key must not be empty.";
     headers->AppendValueOrAddHeader(key, value);
   }
 }
@@ -190,7 +190,7 @@ class PriorityGetter : public BufferedSpdyFramerVisitorInterface {
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {}
   void OnSettings() override {}
   void OnSettingsAck() override {}
-  void OnSetting(SpdyKnownSettingsId id, uint32_t value) override {}
+  void OnSetting(SpdySettingsId id, uint32_t value) override {}
   void OnSettingsEnd() override {}
   void OnPing(SpdyPingId unique_id, bool is_ack) override {}
   void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {}
@@ -1059,4 +1059,55 @@ SpdyHeaderBlock SpdyTestUtil::ConstructHeaderBlock(SpdyStringPiece method,
   return headers;
 }
 
+namespace test {
+HashValue GetTestHashValue(uint8_t label) {
+  HashValue hash_value(HASH_VALUE_SHA256);
+  memset(hash_value.data(), label, hash_value.size());
+  return hash_value;
+}
+
+SpdyString GetTestPin(uint8_t label) {
+  HashValue hash_value = GetTestHashValue(label);
+  SpdyString base64;
+  base::Base64Encode(SpdyStringPiece(reinterpret_cast<char*>(hash_value.data()),
+                                     hash_value.size()),
+                     &base64);
+
+  return SpdyString("pin-sha256=\"") + base64 + "\"";
+}
+
+void AddPin(TransportSecurityState* state,
+            const SpdyString& host,
+            uint8_t primary_label,
+            uint8_t backup_label) {
+  SpdyString primary_pin = GetTestPin(primary_label);
+  SpdyString backup_pin = GetTestPin(backup_label);
+  SpdyString header = "max-age = 10000; " + primary_pin + "; " + backup_pin;
+
+  // Construct a fake SSLInfo that will pass AddHPKPHeader's checks.
+  SSLInfo ssl_info;
+  ssl_info.is_issued_by_known_root = true;
+  ssl_info.public_key_hashes.push_back(GetTestHashValue(primary_label));
+  EXPECT_TRUE(state->AddHPKPHeader(host, header, ssl_info));
+}
+
+TestServerPushDelegate::TestServerPushDelegate() = default;
+
+TestServerPushDelegate::~TestServerPushDelegate() = default;
+
+void TestServerPushDelegate::OnPush(
+    std::unique_ptr<ServerPushHelper> push_helper,
+    const NetLogWithSource& session_net_log) {
+  push_helpers[push_helper->GetURL()] = std::move(push_helper);
+}
+
+bool TestServerPushDelegate::CancelPush(GURL url) {
+  auto itr = push_helpers.find(url);
+  DCHECK(itr != push_helpers.end());
+  itr->second->Cancel();
+  push_helpers.erase(itr);
+  return true;
+}
+
+}  // namespace test
 }  // namespace net
diff --git a/chromium/net/spdy/chromium/spdy_test_util_common.h b/chromium/net/spdy/chromium/spdy_test_util_common.h
index c7187b38457..44e01782750 100644
--- a/chromium/net/spdy/chromium/spdy_test_util_common.h
+++ b/chromium/net/spdy/chromium/spdy_test_util_common.h
@@ -29,7 +29,7 @@
 #include "net/http/http_response_info.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/transport_security_state.h"
-#include "net/proxy_resolution/proxy_service.h"
+#include "net/proxy_resolution/proxy_resolution_service.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/chromium/spdy_session.h"
 #include "net/spdy/core/spdy_protocol.h"
@@ -46,12 +46,14 @@ namespace net {
 
 class CTVerifier;
 class CTPolicyEnforcer;
+class HashValue;
 class HostPortPair;
 class NetLogWithSource;
 class SpdySessionKey;
 class SpdySessionPool;
 class SpdyStream;
 class SpdyStreamRequest;
+class TransportSecurityState;
 
 // Default upload data used by both, mock objects and framer when creating
 // data frames.
@@ -495,6 +497,38 @@ class SpdyTestUtil {
   std::map<int, std::vector<int>> priority_to_stream_id_list_;
 };
 
+namespace test {
+
+// Returns a SHA1 HashValue in which each byte has the value |label|.
+HashValue GetTestHashValue(uint8_t label);
+
+// Returns SHA1 pinning header for the of the base64 encoding of
+// GetTestHashValue(|label|).
+SpdyString GetTestPin(uint8_t label);
+
+// Adds a pin for |host| to |state|.
+void AddPin(TransportSecurityState* state,
+            const SpdyString& host,
+            uint8_t primary_label,
+            uint8_t backup_label);
+
+// A test implementation of ServerPushDelegate that caches all the pushed
+// request and provides a interface to cancel the push given url.
+class TestServerPushDelegate : public ServerPushDelegate {
+ public:
+  TestServerPushDelegate();
+  ~TestServerPushDelegate() override;
+
+  void OnPush(std::unique_ptr<ServerPushHelper> push_helper,
+              const NetLogWithSource& session_net_log) override;
+
+  bool CancelPush(GURL url);
+
+ private:
+  std::map<GURL, std::unique_ptr<ServerPushHelper>> push_helpers;
+};
+
+}  // namespace test
 }  // namespace net
 
 #endif  // NET_SPDY_CHROMIUM_SPDY_TEST_UTIL_COMMON_H_
diff --git a/chromium/net/spdy/core/hpack/hpack_encoder.cc b/chromium/net/spdy/core/hpack/hpack_encoder.cc
index 824b0a3e3eb..09c4d08802c 100644
--- a/chromium/net/spdy/core/hpack/hpack_encoder.cc
+++ b/chromium/net/spdy/core/hpack/hpack_encoder.cc
@@ -85,12 +85,6 @@ HpackEncoder::HpackEncoder(const HpackHuffmanTable& table)
 
 HpackEncoder::~HpackEncoder() = default;
 
-void HpackEncoder::EncodeHeaderSet(const Representations& representations,
-                                   SpdyString* output) {
-  RepresentationIterator iter(representations);
-  EncodeRepresentations(&iter, output);
-}
-
 bool HpackEncoder::EncodeHeaderSet(const SpdyHeaderBlock& header_set,
                                    SpdyString* output) {
   // Separate header set into pseudo-headers and regular headers.
diff --git a/chromium/net/spdy/core/hpack/hpack_encoder.h b/chromium/net/spdy/core/hpack/hpack_encoder.h
index 030afa5d2b1..aa60045d0af 100644
--- a/chromium/net/spdy/core/hpack/hpack_encoder.h
+++ b/chromium/net/spdy/core/hpack/hpack_encoder.h
@@ -50,10 +50,6 @@ class SPDY_EXPORT_PRIVATE HpackEncoder {
   explicit HpackEncoder(const HpackHuffmanTable& table);
   ~HpackEncoder();
 
-  // Encodes a sequence of Representations into the given string.
-  void EncodeHeaderSet(const Representations& representations,
-                       SpdyString* output);
-
   // Encodes the given header set into the given string. Returns
   // whether or not the encoding was successful.
   bool EncodeHeaderSet(const SpdyHeaderBlock& header_set, SpdyString* output);
diff --git a/chromium/net/spdy/core/hpack/hpack_entry.cc b/chromium/net/spdy/core/hpack/hpack_entry.cc
index a948877cd6d..84e21f5f54b 100644
--- a/chromium/net/spdy/core/hpack/hpack_entry.cc
+++ b/chromium/net/spdy/core/hpack/hpack_entry.cc
@@ -7,6 +7,7 @@
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
+#include "net/spdy/platform/api/spdy_string_utils.h"
 
 namespace net {
 
@@ -75,11 +76,10 @@ size_t HpackEntry::Size() const {
 }
 
 SpdyString HpackEntry::GetDebugString() const {
-  return "{ name: \"" + SpdyString(name_ref_) + "\", value: \"" +
-         SpdyString(value_ref_) +
-         "\", index: " + base::NumberToString(insertion_index_) +
-         (IsStatic() ? " static" : (IsLookup() ? " lookup" : " dynamic")) +
-         " }";
+  return SpdyStringPrintf(
+      "{ name: \"%.*s\", value: \"%.*s\", index: %d %s }", name_ref_.size(),
+      name_ref_.data(), value_ref_.size(), value_ref_.data(), insertion_index_,
+      (IsStatic() ? " static" : (IsLookup() ? " lookup" : " dynamic")));
 }
 
 size_t HpackEntry::EstimateMemoryUsage() const {
diff --git a/chromium/net/spdy/core/http2_frame_decoder_adapter.cc b/chromium/net/spdy/core/http2_frame_decoder_adapter.cc
index 2922d8fa5e4..288dd45599c 100644
--- a/chromium/net/spdy/core/http2_frame_decoder_adapter.cc
+++ b/chromium/net/spdy/core/http2_frame_decoder_adapter.cc
@@ -34,6 +34,7 @@
 #include "net/spdy/core/spdy_headers_handler_interface.h"
 #include "net/spdy/core/spdy_protocol.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
+#include "net/spdy/platform/api/spdy_flags.h"
 #include "net/spdy/platform/api/spdy_ptr_util.h"
 #include "net/spdy/platform/api/spdy_string_utils.h"
 
@@ -474,16 +475,23 @@ void Http2DecoderAdapter::OnSettingsStart(const Http2FrameHeader& header) {
 void Http2DecoderAdapter::OnSetting(const Http2SettingFields& setting_fields) {
   DVLOG(1) << "OnSetting: " << setting_fields;
   const auto parameter = static_cast<SpdySettingsId>(setting_fields.parameter);
+  if (GetSpdyRestartFlag(http2_propagate_unknown_settings)) {
+    visitor()->OnSetting(parameter, setting_fields.value);
+    if (extension_ != nullptr) {
+      extension_->OnSetting(parameter, setting_fields.value);
+    }
+    return;
+  }
   SpdyKnownSettingsId setting_id;
   if (!ParseSettingsId(parameter, &setting_id)) {
     if (extension_ == nullptr) {
-      DVLOG(1) << "Ignoring unknown setting id: " << setting_fields;
+      DVLOG(1) << "No extension for unknown setting id: " << setting_fields;
     } else {
       extension_->OnSetting(parameter, setting_fields.value);
     }
     return;
   }
-  visitor()->OnSetting(setting_id, setting_fields.value);
+  visitor()->OnSettingOld(setting_id, setting_fields.value);
 }
 
 void Http2DecoderAdapter::OnSettingsEnd() {
diff --git a/chromium/net/spdy/core/http2_frame_decoder_adapter.h b/chromium/net/spdy/core/http2_frame_decoder_adapter.h
index b8cf74101e3..65276416901 100644
--- a/chromium/net/spdy/core/http2_frame_decoder_adapter.h
+++ b/chromium/net/spdy/core/http2_frame_decoder_adapter.h
@@ -396,7 +396,13 @@ class SPDY_EXPORT_PRIVATE SpdyFramerVisitorInterface {
 
   // Called when a complete setting within a SETTINGS frame has been parsed and
   // validated.
-  virtual void OnSetting(SpdyKnownSettingsId id, uint32_t value) = 0;
+  // TODO(diannahu): Remove with deprecation of
+  //     GetSpdyRestartFlag(http2_propagate_unknown_settings).
+  virtual void OnSettingOld(SpdyKnownSettingsId id, uint32_t value) = 0;
+
+  // Called when a complete setting within a SETTINGS frame has been parsed.
+  // Note that |id| may or may not be a SETTINGS ID defined in the HTTP/2 spec.
+  virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
 
   // Called when a SETTINGS frame is received with the ACK flag set.
   virtual void OnSettingsAck() {}
@@ -485,7 +491,7 @@ class SPDY_EXPORT_PRIVATE ExtensionVisitorInterface {
  public:
   virtual ~ExtensionVisitorInterface() {}
 
-  // Called when non-standard SETTINGS are received.
+  // Called when SETTINGS are received, including non-standard SETTINGS.
   virtual void OnSetting(SpdySettingsId id, uint32_t value) = 0;
 
   // Called when non-standard frames are received.
diff --git a/chromium/net/spdy/core/mock_spdy_framer_visitor.h b/chromium/net/spdy/core/mock_spdy_framer_visitor.h
index 4efbe538454..7bf02ddd814 100644
--- a/chromium/net/spdy/core/mock_spdy_framer_visitor.h
+++ b/chromium/net/spdy/core/mock_spdy_framer_visitor.h
@@ -40,7 +40,8 @@ class MockSpdyFramerVisitor : public SpdyFramerVisitorInterface {
   MOCK_METHOD2(OnRstStream,
                void(SpdyStreamId stream_id, SpdyErrorCode error_code));
   MOCK_METHOD0(OnSettings, void());
-  MOCK_METHOD2(OnSetting, void(SpdyKnownSettingsId id, uint32_t value));
+  MOCK_METHOD2(OnSettingOld, void(SpdyKnownSettingsId id, uint32_t value));
+  MOCK_METHOD2(OnSetting, void(SpdySettingsId id, uint32_t value));
   MOCK_METHOD2(OnPing, void(SpdyPingId unique_id, bool is_ack));
   MOCK_METHOD0(OnSettingsEnd, void());
   MOCK_METHOD2(OnGoAway,
diff --git a/chromium/net/spdy/core/spdy_deframer_visitor.cc b/chromium/net/spdy/core/spdy_deframer_visitor.cc
index 99ee8998662..f92dcedbc0e 100644
--- a/chromium/net/spdy/core/spdy_deframer_visitor.cc
+++ b/chromium/net/spdy/core/spdy_deframer_visitor.cc
@@ -16,6 +16,7 @@
 #include "net/spdy/core/spdy_frame_reader.h"
 #include "net/spdy/core/spdy_protocol.h"
 #include "net/spdy/core/spdy_test_utils.h"
+#include "net/spdy/platform/api/spdy_flags.h"
 #include "net/spdy/platform/api/spdy_ptr_util.h"
 #include "net/spdy/platform/api/spdy_string_piece.h"
 
@@ -164,7 +165,8 @@ class SpdyTestDeframerImpl : public SpdyTestDeframer,
                      SpdyStreamId promised_stream_id,
                      bool end) override;
   void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override;
-  void OnSetting(SpdyKnownSettingsId id, uint32_t value) override;
+  void OnSettingOld(SpdyKnownSettingsId id, uint32_t value) override;
+  void OnSetting(SpdySettingsId id, uint32_t value) override;
   void OnSettings() override;
   void OnSettingsAck() override;
   void OnSettingsEnd() override;
@@ -602,10 +604,11 @@ void SpdyTestDeframerImpl::OnRstStream(SpdyStreamId stream_id,
       SpdyMakeUnique<SpdyRstStreamIR>(stream_id, error_code));
 }
 
-// Called for an individual setting. There is no negotiation, the sender is
+// Called for an individual setting. There is no negotiation; the sender is
 // stating the value that the sender is using.
-void SpdyTestDeframerImpl::OnSetting(SpdyKnownSettingsId id, uint32_t value) {
-  DVLOG(1) << "OnSetting id: " << id << std::hex << "    value: " << value;
+void SpdyTestDeframerImpl::OnSettingOld(SpdyKnownSettingsId id,
+                                        uint32_t value) {
+  DVLOG(1) << "OnSettingOld id: " << id << std::hex << "    value: " << value;
   CHECK_EQ(frame_type_, SETTINGS) << "   frame_type_="
                                   << Http2FrameTypeToString(frame_type_);
   CHECK(settings_);
@@ -613,6 +616,20 @@ void SpdyTestDeframerImpl::OnSetting(SpdyKnownSettingsId id, uint32_t value) {
   settings_ir_->AddSetting(id, value);
 }
 
+// Called for an individual setting. There is no negotiation; the sender is
+// stating the value that the sender is using.
+void SpdyTestDeframerImpl::OnSetting(SpdySettingsId id, uint32_t value) {
+  DVLOG(1) << "OnSetting id: " << id << std::hex << "    value: " << value;
+  CHECK_EQ(frame_type_, SETTINGS)
+      << "   frame_type_=" << Http2FrameTypeToString(frame_type_);
+  CHECK(settings_);
+  SpdyKnownSettingsId known_id;
+  if (ParseSettingsId(id, &known_id)) {
+    settings_->push_back(std::make_pair(known_id, value));
+    settings_ir_->AddSetting(known_id, value);
+  }
+}
+
 // Called at the start of a SETTINGS frame with setting entries, but not the
 // (required) ACK of a SETTINGS frame. There is no stream_id because
 // the settings apply to the entire connection, not to an individual stream.
diff --git a/chromium/net/spdy/core/spdy_framer.cc b/chromium/net/spdy/core/spdy_framer.cc
index 1943fb4074e..484ce25bec1 100644
--- a/chromium/net/spdy/core/spdy_framer.cc
+++ b/chromium/net/spdy/core/spdy_framer.cc
@@ -15,7 +15,6 @@
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
-#include "net/quic/platform/api/quic_flags.h"
 #include "net/spdy/core/hpack/hpack_constants.h"
 #include "net/spdy/core/spdy_bitmasks.h"
 #include "net/spdy/core/spdy_bug_tracker.h"
diff --git a/chromium/net/spdy/core/spdy_framer_test.cc b/chromium/net/spdy/core/spdy_framer_test.cc
index 4b7cf59c461..d2336f7b8e2 100644
--- a/chromium/net/spdy/core/spdy_framer_test.cc
+++ b/chromium/net/spdy/core/spdy_framer_test.cc
@@ -15,7 +15,6 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
-#include "net/quic/platform/api/quic_flags.h"
 #include "net/spdy/core/array_output_buffer.h"
 #include "net/spdy/core/hpack/hpack_constants.h"
 #include "net/spdy/core/mock_spdy_framer_visitor.h"
@@ -334,7 +333,12 @@ class TestSpdyVisitor : public SpdyFramerVisitorInterface,
     ++fin_frame_count_;
   }
 
-  void OnSetting(SpdyKnownSettingsId id, uint32_t value) override {
+  void OnSettingOld(SpdyKnownSettingsId id, uint32_t value) override {
+    VLOG(1) << "OnSetting(" << id << ", " << std::hex << value << ")";
+    ++setting_count_;
+  }
+
+  void OnSetting(SpdySettingsId id, uint32_t value) override {
     VLOG(1) << "OnSetting(" << id << ", " << std::hex << value << ")";
     ++setting_count_;
   }
@@ -3008,14 +3012,19 @@ TEST_P(SpdyFramerTest, ReadUnknownSettingsId) {
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
-  // In HTTP/2, we ignore unknown settings because of extensions.
-  EXPECT_EQ(0, visitor.setting_count_);
+  // In HTTP/2, we ignore unknown settings because of extensions. However, we
+  // pass the SETTINGS to the visitor, which can decide how to handle them.
+  if (GetSpdyRestartFlag(http2_propagate_unknown_settings)) {
+    EXPECT_EQ(1, visitor.setting_count_);
+  } else {
+    EXPECT_EQ(0, visitor.setting_count_);
+  }
   EXPECT_EQ(0, visitor.error_count_);
 }
 
-TEST_P(SpdyFramerTest, ReadUnknownSettingsWithExtension) {
+TEST_P(SpdyFramerTest, ReadKnownAndUnknownSettingsWithExtension) {
   const unsigned char kH2FrameData[] = {
-      0x00, 0x00, 0x0c,        // Length: 12
+      0x00, 0x00, 0x12,        // Length: 18
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
@@ -3023,6 +3032,8 @@ TEST_P(SpdyFramerTest, ReadUnknownSettingsWithExtension) {
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
       0x00, 0x5f,              //  Param: 95
       0x00, 0x01, 0x00, 0x02,  //  Value: 65538
+      0x00, 0x02,              //  Param: ENABLE_PUSH
+      0x00, 0x00, 0x00, 0x01,  //  Value: 1
   };
 
   TestSpdyVisitor visitor(SpdyFramer::DISABLE_COMPRESSION);
@@ -3030,13 +3041,26 @@ TEST_P(SpdyFramerTest, ReadUnknownSettingsWithExtension) {
   visitor.set_extension_visitor(&extension);
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
-  // In HTTP/2, we ignore unknown settings because of extensions.
-  EXPECT_EQ(0, visitor.setting_count_);
+  // In HTTP/2, we ignore unknown settings because of extensions. However, we
+  // pass the SETTINGS to the visitor, which can decide how to handle them.
+  if (GetSpdyRestartFlag(http2_propagate_unknown_settings)) {
+    EXPECT_EQ(3, visitor.setting_count_);
+  } else {
+    EXPECT_EQ(1, visitor.setting_count_);
+  }
   EXPECT_EQ(0, visitor.error_count_);
 
-  EXPECT_THAT(
-      extension.settings_received_,
-      testing::ElementsAre(testing::Pair(16, 2), testing::Pair(95, 65538)));
+  if (GetSpdyRestartFlag(http2_propagate_unknown_settings)) {
+    // The extension receives all SETTINGS, including the non-standard SETTINGS.
+    EXPECT_THAT(
+        extension.settings_received_,
+        testing::ElementsAre(testing::Pair(16, 2), testing::Pair(95, 65538),
+                             testing::Pair(2, 1)));
+  } else {
+    EXPECT_THAT(
+        extension.settings_received_,
+        testing::ElementsAre(testing::Pair(16, 2), testing::Pair(95, 65538)));
+  }
 }
 
 // Tests handling of SETTINGS frame with entries out of order.
@@ -3888,7 +3912,11 @@ TEST_P(SpdyFramerTest, SettingsFrameFlags) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnSettings());
-      EXPECT_CALL(visitor, OnSetting(SETTINGS_INITIAL_WINDOW_SIZE, 16));
+      if (GetSpdyRestartFlag(http2_propagate_unknown_settings)) {
+        EXPECT_CALL(visitor, OnSetting(SETTINGS_INITIAL_WINDOW_SIZE, 16));
+      } else {
+        EXPECT_CALL(visitor, OnSettingOld(SETTINGS_INITIAL_WINDOW_SIZE, 16));
+      }
       EXPECT_CALL(visitor, OnSettingsEnd());
     }
 
diff --git a/chromium/net/spdy/core/spdy_header_block.cc b/chromium/net/spdy/core/spdy_header_block.cc
index fb2c4cb0c9b..a182c9c678a 100644
--- a/chromium/net/spdy/core/spdy_header_block.cc
+++ b/chromium/net/spdy/core/spdy_header_block.cc
@@ -11,10 +11,7 @@
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/values.h"
 #include "net/base/arena.h"
-#include "net/http/http_log_util.h"
-#include "net/log/net_log_capture_mode.h"
 #include "net/spdy/platform/api/spdy_estimate_memory_usage.h"
 #include "net/spdy/platform/api/spdy_ptr_util.h"
 #include "net/spdy/platform/api/spdy_string_utils.h"
@@ -363,22 +360,6 @@ SpdyHeaderBlock::Storage* SpdyHeaderBlock::GetStorage() {
   return storage_.get();
 }
 
-std::unique_ptr<base::Value> SpdyHeaderBlockNetLogCallback(
-    const SpdyHeaderBlock* headers,
-    NetLogCaptureMode capture_mode) {
-  auto dict = std::make_unique<base::DictionaryValue>();
-  auto headers_dict = std::make_unique<base::DictionaryValue>();
-  for (SpdyHeaderBlock::const_iterator it = headers->begin();
-       it != headers->end(); ++it) {
-    headers_dict->SetKey(
-        it->first.as_string(),
-        base::Value(ElideHeaderValueForNetLog(
-            capture_mode, it->first.as_string(), it->second.as_string())));
-  }
-  dict->Set("headers", std::move(headers_dict));
-  return std::move(dict);
-}
-
 SpdyStringPiece SpdyHeaderBlock::WriteKey(const SpdyStringPiece key) {
   key_size_ += key.size();
   return GetStorage()->Write(key);
diff --git a/chromium/net/spdy/core/spdy_header_block.h b/chromium/net/spdy/core/spdy_header_block.h
index 248ec73f0be..e5a934fbbce 100644
--- a/chromium/net/spdy/core/spdy_header_block.h
+++ b/chromium/net/spdy/core/spdy_header_block.h
@@ -15,19 +15,12 @@
 
 #include "base/macros.h"
 #include "net/base/linked_hash_map.h"
-#include "net/log/net_log.h"
 #include "net/spdy/platform/api/spdy_export.h"
 #include "net/spdy/platform/api/spdy_string.h"
 #include "net/spdy/platform/api/spdy_string_piece.h"
 
-namespace base {
-class Value;
-}
-
 namespace net {
 
-class NetLogCaptureMode;
-
 namespace test {
 class SpdyHeaderBlockPeer;
 class ValueProxyPeer;
@@ -256,11 +249,6 @@ SPDY_EXPORT_PRIVATE size_t Join(char* dst,
                                 const std::vector<SpdyStringPiece>& fragments,
                                 SpdyStringPiece separator);
 
-// Converts a SpdyHeaderBlock into NetLog event parameters.
-SPDY_EXPORT_PRIVATE std::unique_ptr<base::Value> SpdyHeaderBlockNetLogCallback(
-    const SpdyHeaderBlock* headers,
-    NetLogCaptureMode capture_mode);
-
 }  // namespace net
 
 #endif  // NET_SPDY_CORE_SPDY_HEADER_BLOCK_H_
diff --git a/chromium/net/spdy/core/spdy_header_block_test.cc b/chromium/net/spdy/core/spdy_header_block_test.cc
index da0eb7d6d6a..07d05234c3a 100644
--- a/chromium/net/spdy/core/spdy_header_block_test.cc
+++ b/chromium/net/spdy/core/spdy_header_block_test.cc
@@ -8,7 +8,6 @@
 #include <utility>
 
 #include "base/values.h"
-#include "net/log/net_log_capture_mode.h"
 #include "net/spdy/core/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
diff --git a/chromium/net/spdy/core/spdy_no_op_visitor.h b/chromium/net/spdy/core/spdy_no_op_visitor.h
index 6dabfcf1ef2..cacd527d172 100644
--- a/chromium/net/spdy/core/spdy_no_op_visitor.h
+++ b/chromium/net/spdy/core/spdy_no_op_visitor.h
@@ -39,7 +39,8 @@ class SpdyNoOpVisitor : public SpdyFramerVisitorInterface,
   void OnStreamEnd(SpdyStreamId stream_id) override {}
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {}
   void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {}
-  void OnSetting(SpdyKnownSettingsId id, uint32_t value) override {}
+  void OnSettingOld(SpdyKnownSettingsId id, uint32_t value) override {}
+  void OnSetting(SpdySettingsId id, uint32_t value) override {}
   void OnPing(SpdyPingId unique_id, bool is_ack) override {}
   void OnSettingsEnd() override {}
   void OnSettingsAck() override {}
diff --git a/chromium/net/spdy/core/spdy_protocol.cc b/chromium/net/spdy/core/spdy_protocol.cc
index e67fbd4870c..53d34fe7640 100644
--- a/chromium/net/spdy/core/spdy_protocol.cc
+++ b/chromium/net/spdy/core/spdy_protocol.cc
@@ -7,7 +7,6 @@
 #include <ostream>
 
 #include "net/spdy/core/spdy_bug_tracker.h"
-#include "net/spdy/platform/api/spdy_flags.h"
 #include "net/spdy/platform/api/spdy_ptr_util.h"
 #include "net/spdy/platform/api/spdy_string_utils.h"
 
@@ -140,26 +139,22 @@ bool ParseSettingsId(SpdySettingsId wire_setting_id,
   }
 
   *setting_id = static_cast<SpdyKnownSettingsId>(wire_setting_id);
-  if (GetSpdyReloadableFlag(http2_check_settings_id_007)) {
-    // This switch ensures that the casted value is valid. The default case is
-    // explicitly omitted to have compile-time guarantees that new additions to
-    // |SpdyKnownSettingsId| must also be handled here.
-    switch (*setting_id) {
-      case SETTINGS_HEADER_TABLE_SIZE:
-      case SETTINGS_ENABLE_PUSH:
-      case SETTINGS_MAX_CONCURRENT_STREAMS:
-      case SETTINGS_INITIAL_WINDOW_SIZE:
-      case SETTINGS_MAX_FRAME_SIZE:
-      case SETTINGS_MAX_HEADER_LIST_SIZE:
-      case SETTINGS_ENABLE_CONNECT_PROTOCOL:
-      case SETTINGS_EXPERIMENT_SCHEDULER:
-        // FALLTHROUGH_INTENDED
-        return true;
-    }
-    return false;
-  } else {
-    return true;
+  // This switch ensures that the casted value is valid. The default case is
+  // explicitly omitted to have compile-time guarantees that new additions to
+  // |SpdyKnownSettingsId| must also be handled here.
+  switch (*setting_id) {
+    case SETTINGS_HEADER_TABLE_SIZE:
+    case SETTINGS_ENABLE_PUSH:
+    case SETTINGS_MAX_CONCURRENT_STREAMS:
+    case SETTINGS_INITIAL_WINDOW_SIZE:
+    case SETTINGS_MAX_FRAME_SIZE:
+    case SETTINGS_MAX_HEADER_LIST_SIZE:
+    case SETTINGS_ENABLE_CONNECT_PROTOCOL:
+    case SETTINGS_EXPERIMENT_SCHEDULER:
+      // FALLTHROUGH_INTENDED
+      return true;
   }
+  return false;
 }
 
 SpdyString SettingsIdToString(SpdySettingsId id) {
diff --git a/chromium/net/spdy/core/spdy_protocol.h b/chromium/net/spdy/core/spdy_protocol.h
index 347090b8fb6..7e7d50d2e8d 100644
--- a/chromium/net/spdy/core/spdy_protocol.h
+++ b/chromium/net/spdy/core/spdy_protocol.h
@@ -176,7 +176,7 @@ SPDY_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
 SPDY_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& out,
                                              SpdyFrameType frame_type);
 
-using SettingsMap = std::map<SpdyKnownSettingsId, uint32_t>;
+using SettingsMap = std::map<SpdySettingsId, uint32_t>;
 
 // HTTP/2 error codes, RFC 7540 Section 7.
 enum SpdyErrorCode : uint32_t {
@@ -603,9 +603,7 @@ class SPDY_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR {
 
   // Overwrites as appropriate.
   const SettingsMap& values() const { return values_; }
-  void AddSetting(SpdyKnownSettingsId id, int32_t value) {
-    values_[id] = value;
-  }
+  void AddSetting(SpdySettingsId id, int32_t value) { values_[id] = value; }
 
   bool is_ack() const { return is_ack_; }
   void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
diff --git a/chromium/net/spdy/core/spdy_protocol_test.cc b/chromium/net/spdy/core/spdy_protocol_test.cc
index af4b1b9c5ee..47c2a57bb79 100644
--- a/chromium/net/spdy/core/spdy_protocol_test.cc
+++ b/chromium/net/spdy/core/spdy_protocol_test.cc
@@ -10,7 +10,6 @@
 
 #include "net/spdy/core/spdy_bitmasks.h"
 #include "net/spdy/core/spdy_test_utils.h"
-#include "net/spdy/platform/api/spdy_flags.h"
 #include "net/test/gtest_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -119,12 +118,7 @@ TEST(SpdyProtocolTest, ParseSettingsId) {
   EXPECT_EQ(SETTINGS_MAX_FRAME_SIZE, setting_id);
   EXPECT_TRUE(ParseSettingsId(6, &setting_id));
   EXPECT_EQ(SETTINGS_MAX_HEADER_LIST_SIZE, setting_id);
-  if (GetSpdyReloadableFlag(http2_check_settings_id_007)) {
-    EXPECT_FALSE(ParseSettingsId(7, &setting_id));
-  } else {
-    EXPECT_TRUE(ParseSettingsId(7, &setting_id));
-    EXPECT_EQ(0x07, setting_id);
-  }
+  EXPECT_FALSE(ParseSettingsId(7, &setting_id));
   EXPECT_TRUE(ParseSettingsId(8, &setting_id));
   EXPECT_EQ(SETTINGS_ENABLE_CONNECT_PROTOCOL, setting_id);
   EXPECT_FALSE(ParseSettingsId(9, &setting_id));
diff --git a/chromium/net/spdy/core/spdy_test_utils.cc b/chromium/net/spdy/core/spdy_test_utils.cc
index e8e29f7b7b8..050eaf2cbf6 100644
--- a/chromium/net/spdy/core/spdy_test_utils.cc
+++ b/chromium/net/spdy/core/spdy_test_utils.cc
@@ -11,11 +11,8 @@
 #include <utility>
 #include <vector>
 
-#include "base/base64.h"
 #include "base/logging.h"
 #include "base/sys_byteorder.h"
-#include "net/http/transport_security_state.h"
-#include "net/ssl/ssl_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -103,37 +100,6 @@ void SetFrameLength(SpdySerializedFrame* frame, size_t length) {
   }
 }
 
-HashValue GetTestHashValue(uint8_t label) {
-  HashValue hash_value(HASH_VALUE_SHA256);
-  memset(hash_value.data(), label, hash_value.size());
-  return hash_value;
-}
-
-SpdyString GetTestPin(uint8_t label) {
-  HashValue hash_value = GetTestHashValue(label);
-  SpdyString base64;
-  base::Base64Encode(SpdyStringPiece(reinterpret_cast<char*>(hash_value.data()),
-                                     hash_value.size()),
-                     &base64);
-
-  return SpdyString("pin-sha256=\"") + base64 + "\"";
-}
-
-void AddPin(TransportSecurityState* state,
-            const SpdyString& host,
-            uint8_t primary_label,
-            uint8_t backup_label) {
-  SpdyString primary_pin = GetTestPin(primary_label);
-  SpdyString backup_pin = GetTestPin(backup_label);
-  SpdyString header = "max-age = 10000; " + primary_pin + "; " + backup_pin;
-
-  // Construct a fake SSLInfo that will pass AddHPKPHeader's checks.
-  SSLInfo ssl_info;
-  ssl_info.is_issued_by_known_root = true;
-  ssl_info.public_key_hashes.push_back(GetTestHashValue(primary_label));
-  EXPECT_TRUE(state->AddHPKPHeader(host, header, ssl_info));
-}
-
 void TestHeadersHandler::OnHeaderBlockStart() {
   block_.clear();
 }
@@ -149,23 +115,5 @@ void TestHeadersHandler::OnHeaderBlockEnd(
   compressed_header_bytes_parsed_ = compressed_header_bytes_parsed;
 }
 
-TestServerPushDelegate::TestServerPushDelegate() = default;
-
-TestServerPushDelegate::~TestServerPushDelegate() = default;
-
-void TestServerPushDelegate::OnPush(
-    std::unique_ptr<ServerPushHelper> push_helper,
-    const NetLogWithSource& session_net_log) {
-  push_helpers[push_helper->GetURL()] = std::move(push_helper);
-}
-
-bool TestServerPushDelegate::CancelPush(GURL url) {
-  auto itr = push_helpers.find(url);
-  DCHECK(itr != push_helpers.end());
-  itr->second->Cancel();
-  push_helpers.erase(itr);
-  return true;
-}
-
 }  // namespace test
 }  // namespace net
diff --git a/chromium/net/spdy/core/spdy_test_utils.h b/chromium/net/spdy/core/spdy_test_utils.h
index 6e6c2e037f1..7afd261e524 100644
--- a/chromium/net/spdy/core/spdy_test_utils.h
+++ b/chromium/net/spdy/core/spdy_test_utils.h
@@ -24,9 +24,6 @@
 
 namespace net {
 
-class HashValue;
-class TransportSecurityState;
-
 inline bool operator==(SpdyStringPiece x,
                        const SpdyHeaderBlock::ValueProxy& y) {
   return x == y.as_string();
@@ -49,19 +46,6 @@ void SetFrameFlags(SpdySerializedFrame* frame, uint8_t flags);
 
 void SetFrameLength(SpdySerializedFrame* frame, size_t length);
 
-// Returns a SHA1 HashValue in which each byte has the value |label|.
-HashValue GetTestHashValue(uint8_t label);
-
-// Returns SHA1 pinning header for the of the base64 encoding of
-// GetTestHashValue(|label|).
-SpdyString GetTestPin(uint8_t label);
-
-// Adds a pin for |host| to |state|.
-void AddPin(TransportSecurityState* state,
-            const SpdyString& host,
-            uint8_t primary_label,
-            uint8_t backup_label);
-
 // A test implementation of SpdyHeadersHandlerInterface that correctly
 // reconstructs multiple header values for the same name.
 class TestHeadersHandler : public SpdyHeadersHandlerInterface {
@@ -89,22 +73,6 @@ class TestHeadersHandler : public SpdyHeadersHandlerInterface {
   DISALLOW_COPY_AND_ASSIGN(TestHeadersHandler);
 };
 
-// A test implementation of ServerPushDelegate that caches all the pushed
-// request and provides a interface to cancel the push given url.
-class TestServerPushDelegate : public ServerPushDelegate {
- public:
-  TestServerPushDelegate();
-  ~TestServerPushDelegate() override;
-
-  void OnPush(std::unique_ptr<ServerPushHelper> push_helper,
-              const NetLogWithSource& session_net_log) override;
-
-  bool CancelPush(GURL url);
-
- private:
-  std::map<GURL, std::unique_ptr<ServerPushHelper>> push_helpers;
-};
-
 }  // namespace test
 }  // namespace net
 
diff --git a/chromium/net/spdy/platform/api/spdy_flags.h b/chromium/net/spdy/platform/api/spdy_flags.h
index 2a81172d479..0f4f34042b6 100644
--- a/chromium/net/spdy/platform/api/spdy_flags.h
+++ b/chromium/net/spdy/platform/api/spdy_flags.h
@@ -8,5 +8,6 @@
 #include "net/spdy/platform/impl/spdy_flags_impl.h"
 
 #define GetSpdyReloadableFlag(flag) GetSpdyReloadableFlagImpl(flag)
+#define GetSpdyRestartFlag(flag) GetSpdyRestartFlagImpl(flag)
 
 #endif  // NET_SPDY_PLATFORM_API_SPDY_FLAGS_H_
diff --git a/chromium/net/spdy/platform/impl/spdy_flags_impl.cc b/chromium/net/spdy/platform/impl/spdy_flags_impl.cc
index bcec96c5d25..61153077e60 100644
--- a/chromium/net/spdy/platform/impl/spdy_flags_impl.cc
+++ b/chromium/net/spdy/platform/impl/spdy_flags_impl.cc
@@ -6,7 +6,9 @@
 
 namespace net {
 
-// Consider SETTINGS identifier 0x07 as invalid.
-bool http2_check_settings_id_007 = true;
+// If true, Http2FrameDecoderAdapter will pass decoded HTTP/2 SETTINGS through
+// the SpdyFramerVisitorInterface callback OnSetting(), which will also accept
+// unknown SETTINGS IDs.
+bool http2_propagate_unknown_settings = true;
 
 }  // namespace net
diff --git a/chromium/net/spdy/platform/impl/spdy_flags_impl.h b/chromium/net/spdy/platform/impl/spdy_flags_impl.h
index 95e26b72da0..434e59d382a 100644
--- a/chromium/net/spdy/platform/impl/spdy_flags_impl.h
+++ b/chromium/net/spdy/platform/impl/spdy_flags_impl.h
@@ -9,12 +9,16 @@
 
 namespace net {
 
-NET_EXPORT_PRIVATE extern bool http2_check_settings_id_007;
+NET_EXPORT_PRIVATE extern bool http2_propagate_unknown_settings;
 
 inline bool GetSpdyReloadableFlagImpl(bool flag) {
   return flag;
 }
 
+inline bool GetSpdyRestartFlagImpl(bool flag) {
+  return flag;
+}
+
 }  // namespace net
 
 #endif  // NET_SPDY_PLATFORM_IMPL_SPDY_FLAGS_IMPL_H_
author	Allan Sandfeld Jensen <allan.jensen@qt.io>	2018-05-15 10:20:33 +0200
committer	Allan Sandfeld Jensen <allan.jensen@qt.io>	2018-05-15 10:28:57 +0000
commit	d17ea114e5ef69ad5d5d7413280a13e6428098aa (patch)
tree	2c01a75df69f30d27b1432467cfe7c1467a498da /chromium/net/spdy
parent	8c5c43c7b138c9b4b0bf56d946e61d3bbc111bec (diff)
download	qtwebengine-chromium-d17ea114e5ef69ad5d5d7413280a13e6428098aa.tar.gz