BASELINE: Update Chromium to 91.0.4472.160

Change-Id: I0def1f08a2412aeed79a9ab95dd50eb5c3f65f31
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

13 files changed, 109 insertions, 17 deletions

diff --git a/chromium/net/websockets/websocket_basic_handshake_stream.cc b/chromium/net/websockets/websocket_basic_handshake_stream.cc
index abf25b43f3c..b89ca64415a 100644
--- a/chromium/net/websockets/websocket_basic_handshake_stream.cc
+++ b/chromium/net/websockets/websocket_basic_handshake_stream.cc
@@ -395,6 +395,10 @@ const std::vector<std::string>& WebSocketBasicHandshakeStream::GetDnsAliases()
   return state_.GetDnsAliases();
 }
 
+base::StringPiece WebSocketBasicHandshakeStream::GetAcceptChViaAlps() const {
+  return {};
+}
+
 std::unique_ptr<WebSocketStream> WebSocketBasicHandshakeStream::Upgrade() {
   // The HttpStreamParser object has a pointer to our ClientSocketHandle. Make
   // sure it does not touch it again before it is destroyed.
diff --git a/chromium/net/websockets/websocket_basic_handshake_stream.h b/chromium/net/websockets/websocket_basic_handshake_stream.h
index 1b92ded49bc..48783472b48 100644
--- a/chromium/net/websockets/websocket_basic_handshake_stream.h
+++ b/chromium/net/websockets/websocket_basic_handshake_stream.h
@@ -13,6 +13,7 @@
 
 #include "base/macros.h"
 #include "base/optional.h"
+#include "base/strings/string_piece.h"
 #include "net/base/completion_once_callback.h"
 #include "net/base/net_export.h"
 #include "net/http/http_basic_state.h"
@@ -75,6 +76,7 @@ class NET_EXPORT_PRIVATE WebSocketBasicHandshakeStream final
   void PopulateNetErrorDetails(NetErrorDetails* details) override;
   HttpStream* RenewStreamForAuth() override;
   const std::vector<std::string>& GetDnsAliases() const override;
+  base::StringPiece GetAcceptChViaAlps() const override;
 
   // This is called from the top level once correct handshake response headers
   // have been received. It creates an appropriate subclass of WebSocketStream
diff --git a/chromium/net/websockets/websocket_basic_stream_adapters.cc b/chromium/net/websockets/websocket_basic_stream_adapters.cc
index db3bd486095..398fd240ecc 100644
--- a/chromium/net/websockets/websocket_basic_stream_adapters.cc
+++ b/chromium/net/websockets/websocket_basic_stream_adapters.cc
@@ -130,6 +130,12 @@ void WebSocketSpdyStreamAdapter::OnHeadersSent() {
     delegate_->OnHeadersSent();
 }
 
+void WebSocketSpdyStreamAdapter::OnEarlyHintsReceived(
+    const spdy::Http2HeaderBlock& headers) {
+  // This callback should not be called for a WebSocket handshake.
+  NOTREACHED();
+}
+
 void WebSocketSpdyStreamAdapter::OnHeadersReceived(
     const spdy::Http2HeaderBlock& response_headers,
     const spdy::Http2HeaderBlock* pushed_request_headers) {
@@ -139,6 +145,17 @@ void WebSocketSpdyStreamAdapter::OnHeadersReceived(
 
 void WebSocketSpdyStreamAdapter::OnDataReceived(
     std::unique_ptr<SpdyBuffer> buffer) {
+  if (!buffer) {
+    // This is slightly wrong semantically, as it's still possible to write to
+    // the stream at this point. However, if the server closes the stream
+    // without waiting for a close frame from us, that means it is not
+    // interested in a clean shutdown. In which case we don't need to worry
+    // about sending any remaining data we might have buffered. This results in
+    // a call to OnClose() which then informs our delegate.
+    stream_->Close();
+    return;
+  }
+
   read_data_.Enqueue(std::move(buffer));
   if (read_callback_)
     std::move(read_callback_).Run(CopySavedReadDataIntoBuffer());
diff --git a/chromium/net/websockets/websocket_basic_stream_adapters.h b/chromium/net/websockets/websocket_basic_stream_adapters.h
index 23b6a90e9b7..e4bb64e4414 100644
--- a/chromium/net/websockets/websocket_basic_stream_adapters.h
+++ b/chromium/net/websockets/websocket_basic_stream_adapters.h
@@ -94,6 +94,7 @@ class NET_EXPORT_PRIVATE WebSocketSpdyStreamAdapter
   // SpdyStream::Delegate methods.
 
   void OnHeadersSent() override;
+  void OnEarlyHintsReceived(const spdy::Http2HeaderBlock& headers) override;
   void OnHeadersReceived(
       const spdy::Http2HeaderBlock& response_headers,
       const spdy::Http2HeaderBlock* pushed_request_headers) override;
diff --git a/chromium/net/websockets/websocket_basic_stream_adapters_test.cc b/chromium/net/websockets/websocket_basic_stream_adapters_test.cc
index 7cbf3551671..2c6a12a4571 100644
--- a/chromium/net/websockets/websocket_basic_stream_adapters_test.cc
+++ b/chromium/net/websockets/websocket_basic_stream_adapters_test.cc
@@ -577,6 +577,60 @@ TEST_F(WebSocketSpdyStreamAdapterTest,
   EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
+// Previously we failed to detect a half-close by the server that indicated the
+// stream should be closed. This test ensures a half-close is correctly
+// detected. See https://crbug.com/1151393.
+TEST_F(WebSocketSpdyStreamAdapterTest, OnHeadersReceivedThenStreamEnd) {
+  spdy::SpdySerializedFrame response_headers(
+      spdy_util_.ConstructSpdyResponseHeaders(1, ResponseHeaders(), false));
+  spdy::SpdySerializedFrame stream_end(
+      spdy_util_.ConstructSpdyDataFrame(1, "", true));
+  MockRead reads[] = {CreateMockRead(response_headers, 1),
+                      CreateMockRead(stream_end, 2),
+                      MockRead(ASYNC, ERR_IO_PENDING, 3),  // pause here
+                      MockRead(ASYNC, 0, 4)};
+  spdy::SpdySerializedFrame request_headers(spdy_util_.ConstructSpdyHeaders(
+      1, RequestHeaders(), DEFAULT_PRIORITY, /* fin = */ false));
+  MockWrite writes[] = {CreateMockWrite(request_headers, 0)};
+  SequencedSocketData data(reads, writes);
+  AddSocketData(&data);
+  AddSSLSocketData();
+
+  EXPECT_CALL(mock_delegate_, OnHeadersSent());
+  EXPECT_CALL(mock_delegate_, OnHeadersReceived(_));
+  EXPECT_CALL(mock_delegate_, OnClose(ERR_CONNECTION_CLOSED));
+
+  base::WeakPtr<SpdySession> session = CreateSpdySession();
+  base::WeakPtr<SpdyStream> stream = CreateSpdyStream(session);
+  WebSocketSpdyStreamAdapter adapter(stream, &mock_delegate_,
+                                     NetLogWithSource());
+  EXPECT_TRUE(adapter.is_initialized());
+
+  int rv = stream->SendRequestHeaders(RequestHeaders(), MORE_DATA_TO_SEND);
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+
+  constexpr int kReadBufSize = 1024;
+  auto read_buf = base::MakeRefCounted<IOBuffer>(kReadBufSize);
+  TestCompletionCallback read_callback;
+  rv = adapter.Read(read_buf.get(), kReadBufSize, read_callback.callback());
+  EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
+
+  EXPECT_TRUE(session);
+  EXPECT_TRUE(stream);
+  rv = read_callback.WaitForResult();
+  EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
+  EXPECT_TRUE(session);
+  EXPECT_FALSE(stream);
+
+  // Close the session.
+  data.Resume();
+
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(data.AllReadDataConsumed());
+  EXPECT_TRUE(data.AllWriteDataConsumed());
+}
+
 TEST_F(WebSocketSpdyStreamAdapterTest, DetachDelegate) {
   spdy::SpdySerializedFrame response_headers(
       spdy_util_.ConstructSpdyResponseHeaders(1, ResponseHeaders(), false));
diff --git a/chromium/net/websockets/websocket_handshake_stream_base.h b/chromium/net/websockets/websocket_handshake_stream_base.h
index 4fa19ad30f5..d1c4bc93ea4 100644
--- a/chromium/net/websockets/websocket_handshake_stream_base.h
+++ b/chromium/net/websockets/websocket_handshake_stream_base.h
@@ -105,7 +105,8 @@ class NET_EXPORT WebSocketHandshakeStreamBase : public HttpStream {
     // underlying HTTP/2 connection has been established but before the stream
     // has been opened.  This cannot be called more than once.
     virtual std::unique_ptr<WebSocketHandshakeStreamBase> CreateHttp2Stream(
-        base::WeakPtr<SpdySession> session) = 0;
+        base::WeakPtr<SpdySession> session,
+        std::vector<std::string> dns_aliases) = 0;
   };
 
   // After the handshake has completed, this method creates a WebSocketStream
diff --git a/chromium/net/websockets/websocket_handshake_stream_create_helper.cc b/chromium/net/websockets/websocket_handshake_stream_create_helper.cc
index 75021b4a4be..b96e151652e 100644
--- a/chromium/net/websockets/websocket_handshake_stream_create_helper.cc
+++ b/chromium/net/websockets/websocket_handshake_stream_create_helper.cc
@@ -48,12 +48,13 @@ WebSocketHandshakeStreamCreateHelper::CreateBasicStream(
 
 std::unique_ptr<WebSocketHandshakeStreamBase>
 WebSocketHandshakeStreamCreateHelper::CreateHttp2Stream(
-    base::WeakPtr<SpdySession> session) {
+    base::WeakPtr<SpdySession> session,
+    std::vector<std::string> dns_aliases) {
   std::vector<std::string> extensions(
       1, "permessage-deflate; client_max_window_bits");
   auto stream = std::make_unique<WebSocketHttp2HandshakeStream>(
-      session, connect_delegate_, requested_subprotocols_, extensions,
-      request_);
+      session, connect_delegate_, requested_subprotocols_, extensions, request_,
+      std::move(dns_aliases));
   request_->OnHttp2HandshakeStreamCreated(stream.get());
   return stream;
 }
diff --git a/chromium/net/websockets/websocket_handshake_stream_create_helper.h b/chromium/net/websockets/websocket_handshake_stream_create_helper.h
index eda441b0988..a684232a74b 100644
--- a/chromium/net/websockets/websocket_handshake_stream_create_helper.h
+++ b/chromium/net/websockets/websocket_handshake_stream_create_helper.h
@@ -48,7 +48,8 @@ class NET_EXPORT_PRIVATE WebSocketHandshakeStreamCreateHelper
 
   // Creates a WebSocketHttp2HandshakeStream over an HTTP/2 connection.
   std::unique_ptr<WebSocketHandshakeStreamBase> CreateHttp2Stream(
-      base::WeakPtr<SpdySession> session) override;
+      base::WeakPtr<SpdySession> session,
+      std::vector<std::string> dns_aliases) override;
 
  private:
   WebSocketStream::ConnectDelegate* const connect_delegate_;
diff --git a/chromium/net/websockets/websocket_handshake_stream_create_helper_test.cc b/chromium/net/websockets/websocket_handshake_stream_create_helper_test.cc
index 7ede1a444d2..2450d886c3a 100644
--- a/chromium/net/websockets/websocket_handshake_stream_create_helper_test.cc
+++ b/chromium/net/websockets/websocket_handshake_stream_create_helper_test.cc
@@ -268,7 +268,7 @@ class WebSocketHandshakeStreamCreateHelperTest
         base::WeakPtr<SpdySession> spdy_session =
             CreateSpdySession(http_network_session.get(), key, net_log);
         std::unique_ptr<WebSocketHandshakeStreamBase> handshake =
-            create_helper.CreateHttp2Stream(spdy_session);
+            create_helper.CreateHttp2Stream(spdy_session, {} /* dns_aliases */);
 
         int rv = handshake->InitializeStream(
             &request_info, true, DEFAULT_PRIORITY, NetLogWithSource(),
diff --git a/chromium/net/websockets/websocket_http2_handshake_stream.cc b/chromium/net/websockets/websocket_http2_handshake_stream.cc
index ee56bd42550..3fa3cf6f682 100644
--- a/chromium/net/websockets/websocket_http2_handshake_stream.cc
+++ b/chromium/net/websockets/websocket_http2_handshake_stream.cc
@@ -44,7 +44,8 @@ WebSocketHttp2HandshakeStream::WebSocketHttp2HandshakeStream(
     WebSocketStream::ConnectDelegate* connect_delegate,
     std::vector<std::string> requested_sub_protocols,
     std::vector<std::string> requested_extensions,
-    WebSocketStreamRequestAPI* request)
+    WebSocketStreamRequestAPI* request,
+    std::vector<std::string> dns_aliases)
     : result_(HandshakeResult::HTTP2_INCOMPLETE),
       session_(session),
       connect_delegate_(connect_delegate),
@@ -55,7 +56,8 @@ WebSocketHttp2HandshakeStream::WebSocketHttp2HandshakeStream(
       request_info_(nullptr),
       stream_closed_(false),
       stream_error_(OK),
-      response_headers_complete_(false) {
+      response_headers_complete_(false),
+      dns_aliases_(std::move(dns_aliases)) {
   DCHECK(connect_delegate);
   DCHECK(request);
 }
@@ -239,8 +241,11 @@ HttpStream* WebSocketHttp2HandshakeStream::RenewStreamForAuth() {
 
 const std::vector<std::string>& WebSocketHttp2HandshakeStream::GetDnsAliases()
     const {
-  static const base::NoDestructor<std::vector<std::string>> emptyvector_result;
-  return *emptyvector_result;
+  return dns_aliases_;
+}
+
+base::StringPiece WebSocketHttp2HandshakeStream::GetAcceptChViaAlps() const {
+  return {};
 }
 
 std::unique_ptr<WebSocketStream> WebSocketHttp2HandshakeStream::Upgrade() {
diff --git a/chromium/net/websockets/websocket_http2_handshake_stream.h b/chromium/net/websockets/websocket_http2_handshake_stream.h
index f6d0b0285cf..d0374c8ea8e 100644
--- a/chromium/net/websockets/websocket_http2_handshake_stream.h
+++ b/chromium/net/websockets/websocket_http2_handshake_stream.h
@@ -14,6 +14,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
+#include "base/strings/string_piece.h"
 #include "net/base/completion_once_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_export.h"
@@ -52,7 +53,8 @@ class NET_EXPORT_PRIVATE WebSocketHttp2HandshakeStream
       WebSocketStream::ConnectDelegate* connect_delegate,
       std::vector<std::string> requested_sub_protocols,
       std::vector<std::string> requested_extensions,
-      WebSocketStreamRequestAPI* request);
+      WebSocketStreamRequestAPI* request,
+      std::vector<std::string> dns_aliases);
 
   ~WebSocketHttp2HandshakeStream() override;
 
@@ -87,6 +89,7 @@ class NET_EXPORT_PRIVATE WebSocketHttp2HandshakeStream
   void PopulateNetErrorDetails(NetErrorDetails* details) override;
   HttpStream* RenewStreamForAuth() override;
   const std::vector<std::string>& GetDnsAliases() const override;
+  base::StringPiece GetAcceptChViaAlps() const override;
 
   // WebSocketHandshakeStreamBase methods.
 
@@ -179,6 +182,12 @@ class NET_EXPORT_PRIVATE WebSocketHttp2HandshakeStream
   // to avoid including extension-related header files here.
   std::unique_ptr<WebSocketExtensionParams> extension_params_;
 
+  // Stores any DNS aliases for the remote endpoint. The alias chain is
+  // preserved in reverse order, from canonical name (i.e. address record name)
+  // through to query name. These are stored in the stream instead of the
+  // session due to complications related to IP-pooling.
+  std::vector<std::string> dns_aliases_;
+
   base::WeakPtrFactory<WebSocketHttp2HandshakeStream> weak_ptr_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketHttp2HandshakeStream);
diff --git a/chromium/net/websockets/websocket_stream_cookie_test.cc b/chromium/net/websockets/websocket_stream_cookie_test.cc
index e8a218ec36d..9eb2e16a8f0 100644
--- a/chromium/net/websockets/websocket_stream_cookie_test.cc
+++ b/chromium/net/websockets/websocket_stream_cookie_test.cc
@@ -140,8 +140,7 @@ TEST_P(WebSocketStreamClientUseCookieTest, ClientUseCookie) {
 
   const GURL url(GetParam().url);
   const GURL cookie_url(GetParam().cookie_url);
-  const url::Origin origin =
-      url::Origin::Create(GURL("http://www.example.com"));
+  const url::Origin origin = url::Origin::Create(GURL(GetParam().url));
   const SiteForCookies site_for_cookies = SiteForCookies::FromOrigin(origin);
   const IsolationInfo isolation_info =
       IsolationInfo::Create(IsolationInfo::RequestType::kOther, origin, origin,
@@ -180,8 +179,7 @@ TEST_P(WebSocketStreamServerSetCookieTest, ServerSetCookie) {
 
   const GURL url(GetParam().url);
   const GURL cookie_url(GetParam().cookie_url);
-  const url::Origin origin =
-      url::Origin::Create(GURL("http://www.example.com"));
+  const url::Origin origin = url::Origin::Create(GURL(GetParam().url));
   const SiteForCookies site_for_cookies = SiteForCookies::FromOrigin(origin);
   const IsolationInfo isolation_info =
       IsolationInfo::Create(IsolationInfo::RequestType::kOther, origin, origin,
diff --git a/chromium/net/websockets/websocket_stream_test.cc b/chromium/net/websockets/websocket_stream_test.cc
index c35bd5bd08a..0c7257fe42b 100644
--- a/chromium/net/websockets/websocket_stream_test.cc
+++ b/chromium/net/websockets/websocket_stream_test.cc
@@ -1561,8 +1561,7 @@ TEST_P(WebSocketStreamCreateBasicAuthTest, OnAuthRequiredSetAuth) {
   EXPECT_FALSE(stream_);
   EXPECT_FALSE(has_failed());
 
-  AuthCredentials credentials(base::ASCIIToUTF16("foo"),
-                              base::ASCIIToUTF16("baz"));
+  AuthCredentials credentials(u"foo", u"baz");
   std::move(on_auth_required_callback_).Run(&credentials);
 
   WaitUntilConnectDone();