Add WebSocketFrameParser.

net/websockets/websocket_frame_parser_unittest.cc

Index: net/websockets/websocket_frame_parser_unittest.cc
diff --git a/net/websockets/websocket_frame_parser_unittest.cc b/net/websockets/websocket_frame_parser_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..eb9f78da2e1357db7a2d30a9ec3290b65579157f
--- /dev/null
+++ b/net/websockets/websocket_frame_parser_unittest.cc
@@ -0,0 +1,247 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/websockets/websocket_frame_parser.h"
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_vector.h"
+#include "net/websockets/websocket_frame.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+const char kHello[] = "Hello, world!";
+const uint64 kHelloLength = arraysize(kHello) - 1;
+const char kHelloFrame[] = "\x81\x0dHello, world!";
+const uint64 kHelloFrameLength = arraysize(kHelloFrame) - 1;
+const char kMaskedHelloFrame[] =
+    "\x81\x8d\xde\xad\xbe\xef"
+    "\x96\xc8\xd2\x83\xb1\x81\x9e\x98\xb1\xdf\xd2\x8b\xff";
+const uint64 kMaskedHelloFrameLength = arraysize(kMaskedHelloFrame) - 1;
+
+namespace net {
+
+TEST(WebSocketFrameParserTest, DecodeNormalFrame) {
+  WebSocketFrameParser parser;
+
+  ScopedVector<WebSocketPartialFrame> frames;
+  EXPECT_TRUE(parser.Decode(kHelloFrame, kHelloFrameLength, &frames));
+  EXPECT_FALSE(parser.failed());
+  ASSERT_EQ(1u, frames.size());
+  WebSocketPartialFrame* frame = frames[0];
+  ASSERT_TRUE(frame != NULL);
+  const WebSocketFrameHeader* header = frame->header.get();
+  EXPECT_TRUE(header != NULL);
+  if (header) {
+    EXPECT_TRUE(header->final);
+    EXPECT_FALSE(header->reserved1);
+    EXPECT_FALSE(header->reserved2);
+    EXPECT_FALSE(header->reserved3);
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+    EXPECT_FALSE(header->masked);
+    EXPECT_EQ(kHelloLength, header->payload_length);
+  }
+  EXPECT_TRUE(frame->final_part);
+
+  std::vector<char> expected_data(kHello, kHello + kHelloLength);
+  EXPECT_EQ(expected_data, frame->data);
+}
+
+TEST(WebSocketFrameParserTest, DecodeMaskedFrame) {
+  WebSocketFrameParser parser;
+
+  ScopedVector<WebSocketPartialFrame> frames;
+  EXPECT_TRUE(parser.Decode(kMaskedHelloFrame, kMaskedHelloFrameLength,
+                            &frames));
+  EXPECT_FALSE(parser.failed());
+  ASSERT_EQ(1u, frames.size());
+  WebSocketPartialFrame* frame = frames[0];
+  ASSERT_TRUE(frame != NULL);
+  const WebSocketFrameHeader* header = frame->header.get();
+  EXPECT_TRUE(header != NULL);
+  if (header) {
+    EXPECT_TRUE(header->final);
+    EXPECT_FALSE(header->reserved1);
+    EXPECT_FALSE(header->reserved2);
+    EXPECT_FALSE(header->reserved3);
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+    EXPECT_TRUE(header->masked);
+    EXPECT_EQ(kHelloLength, header->payload_length);
+  }
+  EXPECT_TRUE(frame->final_part);
+
+  std::vector<char> expected_data(kHello, kHello + kHelloLength);
+  EXPECT_EQ(expected_data, frame->data);
+}
+
+TEST(WebSocketFrameParserTest, DecodeManyFrames) {
+  static const int kRepeat = 10;
+
+  std::vector<char> input;
+  for (int i = 0; i < kRepeat; ++i)
+    input.insert(input.end(), kHelloFrame, kHelloFrame + kHelloFrameLength);
+
+  WebSocketFrameParser parser;
+
+  ScopedVector<WebSocketPartialFrame> frames;
+  EXPECT_TRUE(parser.Decode(&input.front(), input.size(), &frames));
+  EXPECT_FALSE(parser.failed());
+  EXPECT_EQ(static_cast<size_t>(kRepeat), frames.size());
+
+  std::vector<char> expected_data(kHello, kHello + kHelloLength);
+
+  for (size_t i = 0; i < frames.size(); ++i) {
+    WebSocketPartialFrame* frame = frames[i];
+    EXPECT_TRUE(frame != NULL);
+    if (!frame)
+      continue;
+    EXPECT_TRUE(frame->final_part);
+    EXPECT_EQ(expected_data, frame->data);
+
+    const WebSocketFrameHeader* header = frame->header.get();
+    EXPECT_TRUE(header != NULL);
+    if (!header)
+      continue;
+    EXPECT_TRUE(header->final);
+    EXPECT_FALSE(header->reserved1);
+    EXPECT_FALSE(header->reserved2);
+    EXPECT_FALSE(header->reserved3);
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
+    EXPECT_FALSE(header->masked);
+    EXPECT_EQ(kHelloLength, header->payload_length);
+  }
+}
+
+TEST(WebSocketFrameParserTest, DecodePartialFrame) {
+  static const size_t kFrameHeaderSize = 2;
+
+  for (size_t cutting_pos = 0; cutting_pos < kHelloLength - 1; ++cutting_pos) {
+    std::vector<char> input1(kHelloFrame,
+                             kHelloFrame + kFrameHeaderSize + cutting_pos);
+    std::vector<char> input2(kHelloFrame + input1.size(),
+                             kHelloFrame + kHelloFrameLength);
+
+    std::vector<char> expected1(kHello, kHello + cutting_pos);
+    std::vector<char> expected2(kHello + cutting_pos, kHello + kHelloLength);
+
+    WebSocketFrameParser parser;
+
+    ScopedVector<WebSocketPartialFrame> frames1;
+    EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
+    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(1u, frames1.size());
+    if (frames1.size() != 1u)
+      continue;
+    WebSocketPartialFrame* frame1 = frames1[0];
+    EXPECT_TRUE(frame1 != NULL);
+    if (!frame1)
+      continue;
+    EXPECT_FALSE(frame1->final_part);
+    EXPECT_EQ(expected1, frame1->data);
+    const WebSocketFrameHeader* header1 = frame1->header.get();
+    EXPECT_TRUE(header1 != NULL);
+    if (!header1)
+      continue;
+    EXPECT_TRUE(header1->final);
+    EXPECT_FALSE(header1->reserved1);
+    EXPECT_FALSE(header1->reserved2);
+    EXPECT_FALSE(header1->reserved3);
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode);
+    EXPECT_FALSE(header1->masked);
+    EXPECT_EQ(kHelloLength, header1->payload_length);
+
+    ScopedVector<WebSocketPartialFrame> frames2;
+    EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
+    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(1u, frames2.size());
+    if (frames2.size() != 1u)
+      continue;
+    WebSocketPartialFrame* frame2 = frames2[0];
+    EXPECT_TRUE(frame2 != NULL);
+    if (!frame2)
+      continue;
+    EXPECT_TRUE(frame2->final_part);
+    EXPECT_EQ(expected2, frame2->data);
+    const WebSocketFrameHeader* header2 = frame2->header.get();
+    EXPECT_TRUE(header2 != NULL);
+    EXPECT_EQ(header1, header2);
+    if (!header2)
+      continue;
+    EXPECT_TRUE(header2->final);
+    EXPECT_FALSE(header2->reserved1);
+    EXPECT_FALSE(header2->reserved2);
+    EXPECT_FALSE(header2->reserved3);
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header2->opcode);
+    EXPECT_FALSE(header2->masked);
+    EXPECT_EQ(kHelloLength, header2->payload_length);
+  }
+}
+
+TEST(WebSocketFrameParserTest, DecodePartialMaskedFrame) {
+  static const size_t kFrameHeaderSize = 6;
+
+  for (size_t cutting_pos = 0; cutting_pos < kHelloLength - 1; ++cutting_pos) {
+    std::vector<char> input1(
+        kMaskedHelloFrame,
+        kMaskedHelloFrame + kFrameHeaderSize + cutting_pos);
+    std::vector<char> input2(kMaskedHelloFrame + input1.size(),
+                             kMaskedHelloFrame + kMaskedHelloFrameLength);
+
+    std::vector<char> expected1(kHello, kHello + cutting_pos);
+    std::vector<char> expected2(kHello + cutting_pos, kHello + kHelloLength);
+
+    WebSocketFrameParser parser;
+
+    ScopedVector<WebSocketPartialFrame> frames1;
+    EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
+    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(1u, frames1.size());
+    if (frames1.size() != 1u)
+      continue;
+    WebSocketPartialFrame* frame1 = frames1[0];
+    EXPECT_TRUE(frame1 != NULL);
+    if (!frame1)
+      continue;
+    EXPECT_FALSE(frame1->final_part);
+    EXPECT_EQ(expected1, frame1->data);
+    const WebSocketFrameHeader* header1 = frame1->header.get();
+    EXPECT_TRUE(header1 != NULL);
+    if (!header1)
+      continue;
+    EXPECT_TRUE(header1->final);
+    EXPECT_FALSE(header1->reserved1);
+    EXPECT_FALSE(header1->reserved2);
+    EXPECT_FALSE(header1->reserved3);
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode);
+    EXPECT_TRUE(header1->masked);
+    EXPECT_EQ(kHelloLength, header1->payload_length);
+
+    ScopedVector<WebSocketPartialFrame> frames2;
+    EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
+    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(1u, frames2.size());
+    if (frames2.size() != 1u)
+      continue;
+    WebSocketPartialFrame* frame2 = frames2[0];
+    EXPECT_TRUE(frame2 != NULL);
+    if (!frame2)
+      continue;
+    EXPECT_TRUE(frame2->final_part);
+    EXPECT_EQ(expected2, frame2->data);
+    const WebSocketFrameHeader* header2 = frame2->header.get();
+    EXPECT_TRUE(header2 != NULL);
+    EXPECT_EQ(header1, header2);
+    if (!header2)
+      continue;
+    EXPECT_TRUE(header2->final);
+    EXPECT_FALSE(header2->reserved1);
+    EXPECT_FALSE(header2->reserved2);
+    EXPECT_FALSE(header2->reserved3);
+    EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header2->opcode);
+    EXPECT_TRUE(header2->masked);
+    EXPECT_EQ(kHelloLength, header2->payload_length);
+  }
+}
+
+}  // namespace net