Add WebSocketError to indicate decoding failure reason

net/websockets/websocket_frame_parser_unittest.cc

 // 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 <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 12 matching lines @@
 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;
 
 struct FrameHeaderTestCase {
   const char* frame_header;
   size_t frame_header_length;
   uint64 frame_length;
   bool failed;
+  net::WebSocketError error_code;
 };
 
-// TODO(toyoshim): Provide error code and check if the reason is correct.
-const FrameHeaderTestCase kFrameHeaderTests[] = {
-  { "\x81\x00", 2, GG_UINT64_C(0), false },
-  { "\x81\x7D", 2, GG_UINT64_C(125), false },
-  { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126), false },
-  { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF), false },
-  { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000),
-    false },
-  { "\x81\x7F\x00\x00\x00\x00\x7F\xFF\xFF\xFF", 10, GG_UINT64_C(0x7FFFFFFF),
-    false },
-  { "\x81\x7F\x00\x00\x00\x00\x80\x00\x00\x00", 10, GG_UINT64_C(0x80000000),
-    true },
-  { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
-    GG_UINT64_C(0x7FFFFFFFFFFFFFFF), true }
-};
-const int kNumFrameHeaderTests = arraysize(kFrameHeaderTests);
-
 }  // Unnamed namespace
 
 namespace net {
 
+static const FrameHeaderTestCase kFrameHeaderTests[] = {
+  { "\x81\x00", 2, GG_UINT64_C(0), false, WEB_SOCKET_OK },
+  { "\x81\x7D", 2, GG_UINT64_C(125), false, WEB_SOCKET_OK },
+  { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126), false, WEB_SOCKET_OK },
+  { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF), false, WEB_SOCKET_OK },
+  { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000),
+    false, WEB_SOCKET_OK },
+  { "\x81\x7F\x00\x00\x00\x00\x7F\xFF\xFF\xFF", 10, GG_UINT64_C(0x7FFFFFFF),
+    false, WEB_SOCKET_OK },
+  { "\x81\x7F\x00\x00\x00\x00\x80\x00\x00\x00", 10, GG_UINT64_C(0x80000000),
+    true, WEB_SOCKET_ERR_MESSAGE_TOO_BIG },
+  { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
+    GG_UINT64_C(0x7FFFFFFFFFFFFFFF), true, WEB_SOCKET_ERR_MESSAGE_TOO_BIG }
+};
+const int kNumFrameHeaderTests = arraysize(kFrameHeaderTests);

[mmenke, 2012/08/02 14:08:22]

These should still be in the anonymous namespace.  Was thinking you could just
bring the entire anonymous namespace down, and put it inside of the net
namespace.

[Takashi Toyoshima, 2012/08/03 05:53:14]

Ah, sorry. I misunderstand your first comment.
Do you mean move unnamed namespace into net namespace like,

namespace net {
namespace {
  ...
}
TEST...
}

[mmenke, 2012/08/03 14:22:02]

Yes, that's exactly what I meant.

Come to think of it, you could probably put the tests in the anonymous
namespace, too - This is generally a good idea, anyways, except for tests that
need to friends of the classes they test.

+
+
 TEST(WebSocketFrameParserTest, DecodeNormalFrame) {
   WebSocketFrameParser parser;
 
   ScopedVector<WebSocketFrameChunk> frames;
   EXPECT_TRUE(parser.Decode(kHelloFrame, kHelloFrameLength, &frames));
-  EXPECT_FALSE(parser.failed());
+  EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
   ASSERT_EQ(1u, frames.size());
   WebSocketFrameChunk* 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_chunk);
 
   ASSERT_EQ(static_cast<int>(kHelloLength), frame->data->size());
   EXPECT_TRUE(std::equal(kHello, kHello + kHelloLength, frame->data->data()));
 }
 
 TEST(WebSocketFrameParserTest, DecodeMaskedFrame) {
   WebSocketFrameParser parser;
 
   ScopedVector<WebSocketFrameChunk> frames;
   EXPECT_TRUE(parser.Decode(kMaskedHelloFrame, kMaskedHelloFrameLength,
                             &frames));
-  EXPECT_FALSE(parser.failed());
+  EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
   ASSERT_EQ(1u, frames.size());
   WebSocketFrameChunk* 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);
@@ skipping 37 matching lines @@
   for (int i = 0; i < kNumInputs; ++i) {
     input.insert(input.end(),
                  kInputs[i].frame,
                  kInputs[i].frame + kInputs[i].frame_length);
   }
 
   WebSocketFrameParser parser;
 
   ScopedVector<WebSocketFrameChunk> frames;
   EXPECT_TRUE(parser.Decode(&input.front(), input.size(), &frames));
-  EXPECT_FALSE(parser.failed());
+  EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
   ASSERT_EQ(static_cast<size_t>(kNumInputs), frames.size());
 
   for (int i = 0; i < kNumInputs; ++i) {
     WebSocketFrameChunk* frame = frames[i];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     EXPECT_TRUE(frame->final_chunk);
     ASSERT_EQ(kInputs[i].expected_payload_length,
               static_cast<uint64>(frame->data->size()));
@@ skipping 25 matching lines @@
     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<WebSocketFrameChunk> frames1;
     EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
-    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
     EXPECT_EQ(1u, frames1.size());
     if (frames1.size() != 1u)
       continue;
     WebSocketFrameChunk* frame1 = frames1[0];
     EXPECT_TRUE(frame1 != NULL);
     if (!frame1)
       continue;
     EXPECT_FALSE(frame1->final_chunk);
     if (expected1.size() == 0) {
       EXPECT_EQ(NULL, frame1->data.get());
@@ skipping 10 matching lines @@
     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<WebSocketFrameChunk> frames2;
     EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
-    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
     EXPECT_EQ(1u, frames2.size());
     if (frames2.size() != 1u)
       continue;
     WebSocketFrameChunk* frame2 = frames2[0];
     EXPECT_TRUE(frame2 != NULL);
     if (!frame2)
       continue;
     EXPECT_TRUE(frame2->final_chunk);
     if (expected2.size() == 0) {
       EXPECT_EQ(NULL, frame2->data.get());
@@ skipping 18 matching lines @@
     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<WebSocketFrameChunk> frames1;
     EXPECT_TRUE(parser.Decode(&input1.front(), input1.size(), &frames1));
-    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
     EXPECT_EQ(1u, frames1.size());
     if (frames1.size() != 1u)
       continue;
     WebSocketFrameChunk* frame1 = frames1[0];
     EXPECT_TRUE(frame1 != NULL);
     if (!frame1)
       continue;
     EXPECT_FALSE(frame1->final_chunk);
     if (expected1.size() == 0) {
       EXPECT_EQ(NULL, frame1->data.get());
@@ skipping 10 matching lines @@
     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<WebSocketFrameChunk> frames2;
     EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
-    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
     EXPECT_EQ(1u, frames2.size());
     if (frames2.size() != 1u)
       continue;
     WebSocketFrameChunk* frame2 = frames2[0];
     EXPECT_TRUE(frame2 != NULL);
     if (!frame2)
       continue;
     EXPECT_TRUE(frame2->final_chunk);
     if (expected2.size() == 0) {
       EXPECT_EQ(NULL, frame2->data.get());
@@ skipping 18 matching lines @@
     // Limit the payload size not to flood the console on failure.
     static const uint64 kMaxPayloadSize = 200;
     uint64 input_payload_size = std::min(frame_length, kMaxPayloadSize);
     input.insert(input.end(), input_payload_size, 'a');
 
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
     EXPECT_EQ(!kFrameHeaderTests[i].failed,
         parser.Decode(&input.front(), input.size(), &frames));
-    EXPECT_EQ(kFrameHeaderTests[i].failed, parser.failed());
+    EXPECT_EQ(kFrameHeaderTests[i].error_code, parser.websocket_error());
     if (kFrameHeaderTests[i].failed) {
       EXPECT_EQ(0u, frames.size());
     } else {
       EXPECT_EQ(1u, frames.size());
     }
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
@@ skipping 36 matching lines @@
 
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
     // Feed each byte to the parser to see if the parser behaves correctly
     // when it receives partial frame header.
     size_t last_byte_offset = frame_header_length - 1;
     for (size_t j = 0; j < frame_header_length; ++j) {
       bool failed = kFrameHeaderTests[i].failed && j == last_byte_offset;
       EXPECT_EQ(!failed, parser.Decode(frame_header + j, 1, &frames));
-      EXPECT_EQ(failed, parser.failed());
-      if (!kFrameHeaderTests[i].failed && j == last_byte_offset)
+      if (failed) {
+        EXPECT_EQ(kFrameHeaderTests[i].error_code, parser.websocket_error());
+      } else {
+        EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
+      }
+      if (!kFrameHeaderTests[i].failed && j == last_byte_offset) {
         EXPECT_EQ(1u, frames.size());
-      else
+      } else {
         EXPECT_EQ(0u, frames.size());
+      }
     }
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     if (frame_length == 0u) {
       EXPECT_TRUE(frame->final_chunk);
     } else {
@@ skipping 31 matching lines @@
   };
   static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     const char* frame_header = kTests[i].frame_header;
     size_t frame_header_length = kTests[i].frame_header_length;
 
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
-    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
     EXPECT_FALSE(parser.Decode(frame_header, frame_header_length, &frames));
-    EXPECT_TRUE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_ERR_PROTOCOL_ERROR, parser.websocket_error());
     EXPECT_EQ(0u, frames.size());
 
     // Once the parser has failed, it no longer accepts any input (even if
     // the input is empty).
     EXPECT_FALSE(parser.Decode("", 0, &frames));
-    EXPECT_TRUE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_ERR_PROTOCOL_ERROR, parser.websocket_error());
     EXPECT_EQ(0u, frames.size());
   }
 }
 
 TEST(WebSocketFrameParserTest, FrameTypes) {
   struct TestCase {
     const char* frame_header;
     size_t frame_header_length;
     WebSocketFrameHeader::OpCode opcode;
   };
@@ skipping 21 matching lines @@
 
   for (int i = 0; i < kNumTests; ++i) {
     const char* frame_header = kTests[i].frame_header;
     size_t frame_header_length = kTests[i].frame_header_length;
     WebSocketFrameHeader::OpCode opcode = kTests[i].opcode;
 
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
     EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames));
-    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
     EXPECT_EQ(1u, frames.size());
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     EXPECT_TRUE(frame->final_chunk);
     EXPECT_EQ(NULL, frame->data.get());
     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(opcode, header->opcode);
     EXPECT_FALSE(header->masked);
     EXPECT_EQ(0u, header->payload_length);
-  };
+  }
 }
 
 TEST(WebSocketFrameParserTest, FinalBitAndReservedBits) {
   struct TestCase {
     const char* frame_header;
     size_t frame_header_length;
     bool final;
     bool reserved1;
     bool reserved2;
     bool reserved3;
@@ skipping 14 matching lines @@
     size_t frame_header_length = kTests[i].frame_header_length;
     bool final = kTests[i].final;
     bool reserved1 = kTests[i].reserved1;
     bool reserved2 = kTests[i].reserved2;
     bool reserved3 = kTests[i].reserved3;
 
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
     EXPECT_TRUE(parser.Decode(frame_header, frame_header_length, &frames));
-    EXPECT_FALSE(parser.failed());
+    EXPECT_EQ(WEB_SOCKET_OK, parser.websocket_error());
     EXPECT_EQ(1u, frames.size());
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     EXPECT_TRUE(frame->final_chunk);
     EXPECT_EQ(NULL, frame->data.get());
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_EQ(final, header->final);
     EXPECT_EQ(reserved1, header->reserved1);
     EXPECT_EQ(reserved2, header->reserved2);
     EXPECT_EQ(reserved3, header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_FALSE(header->masked);
     EXPECT_EQ(0u, header->payload_length);
   }
 }
 
 }  // namespace net