BASELINE: Update Chromium to 96.0.4664.181

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

1 files changed, 55 insertions, 28 deletions

diff --git a/chromium/net/server/web_socket_encoder.cc b/chromium/net/server/web_socket_encoder.cc
index 760ff6b9ebd..7e5e652786b 100644
--- a/chromium/net/server/web_socket_encoder.cc
+++ b/chromium/net/server/web_socket_encoder.cc
@@ -6,15 +6,16 @@
 
 #include <limits>
 #include <utility>
-#include <vector>
 
 #include "base/check.h"
 #include "base/memory/ptr_util.h"
+#include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/io_buffer.h"
 #include "net/websockets/websocket_deflate_parameters.h"
 #include "net/websockets/websocket_extension.h"
 #include "net/websockets/websocket_extension_parser.h"
+#include "net/websockets/websocket_frame.h"
 
 namespace net {
 
@@ -27,15 +28,6 @@ const int kInflaterChunkSize = 16 * 1024;
 
 // Constants for hybi-10 frame format.
 
-typedef int OpCode;
-
-const OpCode kOpCodeContinuation = 0x0;
-const OpCode kOpCodeText = 0x1;
-const OpCode kOpCodeBinary = 0x2;
-const OpCode kOpCodeClose = 0x8;
-const OpCode kOpCodePing = 0x9;
-const OpCode kOpCodePong = 0xA;
-
 const unsigned char kFinalBit = 0x80;
 const unsigned char kReserved1Bit = 0x40;
 const unsigned char kReserved2Bit = 0x20;
@@ -72,20 +64,24 @@ WebSocket::ParseResult DecodeFrameHybi17(const base::StringPiece& frame,
   int op_code = first_byte & kOpCodeMask;
   bool masked = (second_byte & kMaskBit) != 0;
   *compressed = reserved1;
-  if (!final || reserved2 || reserved3)
+  if (reserved2 || reserved3)
     return WebSocket::FRAME_ERROR;  // Only compression extension is supported.
 
   bool closed = false;
   switch (op_code) {
-    case kOpCodeClose:
+    case WebSocketFrameHeader::OpCodeEnum::kOpCodeClose:
       closed = true;
       break;
-    case kOpCodeText:
+
+    case WebSocketFrameHeader::OpCodeEnum::kOpCodeText:
+    case WebSocketFrameHeader::OpCodeEnum::
+        kOpCodeContinuation:  // Treated in the same as kOpCodeText.
+    case WebSocketFrameHeader::OpCodeEnum::kOpCodePing:
+    case WebSocketFrameHeader::OpCodeEnum::kOpCodePong:
       break;
-    case kOpCodeBinary:        // We don't support binary frames yet.
-    case kOpCodeContinuation:  // We don't support binary frames yet.
-    case kOpCodePing:          // We don't support binary frames yet.
-    case kOpCodePong:          // We don't support binary frames yet.
+
+    case WebSocketFrameHeader::OpCodeEnum::kOpCodeBinary:  // We don't support
+                                                           // binary frames yet.
     default:
       return WebSocket::FRAME_ERROR;
   }
@@ -137,15 +133,25 @@ WebSocket::ParseResult DecodeFrameHybi17(const base::StringPiece& frame,
 
   size_t pos = p + actual_masking_key_length + payload_length - buffer_begin;
   *bytes_consumed = pos;
-  return closed ? WebSocket::FRAME_CLOSE : WebSocket::FRAME_OK;
+
+  if (op_code == WebSocketFrameHeader::OpCodeEnum::kOpCodePing)
+    return WebSocket::FRAME_PING;
+
+  if (op_code == WebSocketFrameHeader::OpCodeEnum::kOpCodePong)
+    return WebSocket::FRAME_PONG;
+
+  if (closed)
+    return WebSocket::FRAME_CLOSE;
+
+  return final ? WebSocket::FRAME_OK_FINAL : WebSocket::FRAME_OK_MIDDLE;
 }
 
 void EncodeFrameHybi17(base::StringPiece message,
                        int masking_key,
                        bool compressed,
+                       WebSocketFrameHeader::OpCodeEnum op_code,
                        std::string* output) {
   std::vector<char> frame;
-  OpCode op_code = kOpCodeText;
   size_t data_length = message.length();
 
   int reserved1 = compressed ? kReserved1Bit : 0;
@@ -292,23 +298,44 @@ WebSocket::ParseResult WebSocketEncoder::DecodeFrame(
     int* bytes_consumed,
     std::string* output) {
   bool compressed;
+  std::string current_output;
   WebSocket::ParseResult result = DecodeFrameHybi17(
-      frame, type_ == FOR_SERVER, bytes_consumed, output, &compressed);
-  if (result == WebSocket::FRAME_OK && compressed) {
-    if (!Inflate(output))
-      result = WebSocket::FRAME_ERROR;
+      frame, type_ == FOR_SERVER, bytes_consumed, &current_output, &compressed);
+  if (result == WebSocket::FRAME_OK_FINAL ||
+      result == WebSocket::FRAME_OK_MIDDLE || result == WebSocket::FRAME_PING) {
+    if (continuation_message_frames_.empty())
+      is_current_message_compressed_ = compressed;
+    continuation_message_frames_.push_back(current_output);
+  }
+  if (result == WebSocket::FRAME_OK_FINAL || result == WebSocket::FRAME_PING) {
+    *output = base::StrCat(continuation_message_frames_);
+    if (is_current_message_compressed_) {
+      if (!Inflate(output))
+        result = WebSocket::FRAME_ERROR;
+    }
   }
+  if (result != WebSocket::FRAME_OK_MIDDLE &&
+      result != WebSocket::FRAME_INCOMPLETE)
+    continuation_message_frames_.clear();
   return result;
 }
 
-void WebSocketEncoder::EncodeFrame(base::StringPiece frame,
-                                   int masking_key,
-                                   std::string* output) {
+void WebSocketEncoder::EncodeTextFrame(base::StringPiece frame,
+                                       int masking_key,
+                                       std::string* output) {
   std::string compressed;
+  constexpr auto op_code = WebSocketFrameHeader::OpCodeEnum::kOpCodeText;
   if (Deflate(frame, &compressed))
-    EncodeFrameHybi17(compressed, masking_key, true, output);
+    EncodeFrameHybi17(compressed, masking_key, true, op_code, output);
   else
-    EncodeFrameHybi17(frame, masking_key, false, output);
+    EncodeFrameHybi17(frame, masking_key, false, op_code, output);
+}
+
+void WebSocketEncoder::EncodePongFrame(base::StringPiece frame,
+                                       int masking_key,
+                                       std::string* output) {
+  constexpr auto op_code = WebSocketFrameHeader::OpCodeEnum::kOpCodePong;
+  EncodeFrameHybi17(frame, masking_key, false, op_code, output);
 }
 
 bool WebSocketEncoder::Inflate(std::string* message) {