Add WebSocketError to indicate decoding failure reason

BUG=none
TEST=net_unittests

Review URL: https://chromiumcodereview.appspot.com/10824081

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@150095 0039d316-1c4b-4281-b951-d872f2087c98

net/websockets/websocket_errors.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/websocket/websocket_errors.h"
+
+namespace net {
+
+Error WebSocketErrorToNetError(WebSocketError error) {
+  switch (error) {
+    case WEB_SOCKET_OK:
+      return OK;
+    case WEB_SOCKET_ERR_PROTOCOL_ERROR:
+      return ERR_WS_PROTOCOL_ERROR;
+    case WEB_SOCKET_ERR_MESSAGE_TOO_BIG:
+      return ERR_MSG_TOO_BIG;
+    default:
+      NOTREACHED();
+  }
+}
+
+}  // namespace net
+
+#endif  // NET_WEBSOCKETS_WEBSOCKET_FRAME_H_

net/websockets/websocket_errors.h

+// 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.
+
+#ifndef NET_WEBSOCKETS_WEBSOCKET_ERRORS_H_
+#define NET_WEBSOCKETS_WEBSOCKET_ERRORS_H_
+
+#include "net/base/net_errors.h"
+
+namespace net {
+
+// Error values for WebSocket framing.
+// This values are compatible to RFC6455 defined status codes.
+enum WebSocketError {
+  WEB_SOCKET_OK = 1000,
+  WEB_SOCKET_ERR_PROTOCOL_ERROR = 1002,
+  WEB_SOCKET_ERR_MESSAGE_TOO_BIG = 1009
+};
+
+// Convert WebSocketError to net::Error defined in net/base/net_errors.h.
+Error WebSocketErrorToNetError(WebSocketError error);
+
+}  // namespace net
+
+#endif  // NET_WEBSOCKETS_WEBSOCKET_FRAME_H_

net/websockets/websocket_frame_parser.cc

@@ -36,7 +36,7 @@ namespace net {
 WebSocketFrameParser::WebSocketFrameParser()
     : current_read_pos_(0),
       frame_offset_(0),
-      failed_(false) {
+      websocket_error_(WEB_SOCKET_OK) {
   std::fill(masking_key_,
             masking_key_ + WebSocketFrameHeader::kMaskingKeyLength,
             '\0');
@@ -49,7 +49,7 @@ bool WebSocketFrameParser::Decode(
     const char* data,
     size_t length,
     ScopedVector<WebSocketFrameChunk>* frame_chunks) {
-  if (failed_)
+  if (websocket_error_ != WEB_SOCKET_OK)
     return false;
   if (!length)
     return true;
@@ -61,7 +61,7 @@ bool WebSocketFrameParser::Decode(
     bool first_chunk = false;
     if (!current_frame_header_.get()) {
       DecodeFrameHeader();
-      if (failed_)
+      if (websocket_error_ != WEB_SOCKET_OK)
         return false;
       // If frame header is incomplete, then carry over the remaining
       // data to the next round of Decode().
@@ -121,8 +121,6 @@ void WebSocketFrameParser::DecodeFrameHeader() {
 
   bool masked = (second_byte & kMaskBit) != 0;
   uint64 payload_length = second_byte & kPayloadLengthMask;
-  bool valid_length_format = true;
-  bool message_too_big = false;
   if (payload_length == kPayloadLengthWithTwoByteExtendedLengthField) {
     if (end - current < 2)
       return;
@@ -131,7 +129,7 @@ void WebSocketFrameParser::DecodeFrameHeader() {
     current += 2;
     payload_length = payload_length_16;
     if (payload_length <= kMaxPayloadLengthWithoutExtendedLengthField)
-      valid_length_format = false;
+      websocket_error_ = WEB_SOCKET_ERR_PROTOCOL_ERROR;
   } else if (payload_length == kPayloadLengthWithEightByteExtendedLengthField) {
     if (end - current < 8)
       return;
@@ -139,13 +137,12 @@ void WebSocketFrameParser::DecodeFrameHeader() {
     current += 8;
     if (payload_length <= kuint16max ||
         payload_length > static_cast<uint64>(kint64max)) {
-      valid_length_format = false;
+      websocket_error_ = WEB_SOCKET_ERR_PROTOCOL_ERROR;
+    } else if (payload_length > static_cast<uint64>(kint32max)) {
+      websocket_error_ = WEB_SOCKET_ERR_MESSAGE_TOO_BIG;
     }
-    if (payload_length > static_cast<uint64>(kint32max))
-      message_too_big = true;
   }
-  if (!valid_length_format || message_too_big) {
-    failed_ = true;
+  if (websocket_error_ != WEB_SOCKET_OK) {
     buffer_.clear();
     current_read_pos_ = 0;
     current_frame_header_.reset();

net/websockets/websocket_frame_parser.h

@@ -12,6 +12,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/net_export.h"
+#include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_frame.h"
 
 namespace net {
@@ -39,9 +40,11 @@ class NET_EXPORT_PRIVATE WebSocketFrameParser {
               size_t length,
               ScopedVector<WebSocketFrameChunk>* frame_chunks);
 
-  // Returns true if the parser has ever failed to decode a WebSocket frame.
-  // TODO(yutak): Provide human-readable description of failure.
-  bool failed() const { return failed_; }
+  // Returns WEB_SOCKET_OK if the parser has not failed to decode WebSocket
+  // frames. Otherwise returns WebSocketError which is defined in
+  // websocket_errors.h. We can convert net::WebSocketError to net::Error by
+  // using WebSocketErrorToNetError().
+  WebSocketError websocket_error() const { return websocket_error_; }
 
  private:
   // Tries to decode a frame header from |current_read_pos_|.
@@ -74,7 +77,7 @@ class NET_EXPORT_PRIVATE WebSocketFrameParser {
   // Amount of payload data read so far for the current frame.
   uint64 frame_offset_;
 
-  bool failed_;
+  WebSocketError websocket_error_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketFrameParser);
 };

net/websockets/websocket_frame_parser_unittest.cc

@@ -14,6 +14,8 @@
 #include "net/websockets/websocket_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace net {
+
 namespace {
 
 const char kHello[] = "Hello, world!";
@@ -29,36 +31,31 @@ struct FrameHeaderTestCase {
   const char* frame_header;
   size_t frame_header_length;
   uint64 frame_length;
-  bool failed;
+  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\x00", 2, GG_UINT64_C(0), WEB_SOCKET_OK },
+  { "\x81\x7D", 2, GG_UINT64_C(125), WEB_SOCKET_OK },
+  { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126), WEB_SOCKET_OK },
+  { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF), 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 }
+    GG_UINT64_C(0x7FFFFFFFFFFFFFFF), WEB_SOCKET_ERR_MESSAGE_TOO_BIG }
 };
 const int kNumFrameHeaderTests = arraysize(kFrameHeaderTests);
 
-}  // Unnamed namespace
-
-namespace net {
-
 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);
@@ -85,7 +82,7 @@ TEST(WebSocketFrameParserTest, DecodeMaskedFrame) {
   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);
@@ -143,7 +140,7 @@ TEST(WebSocketFrameParserTest, DecodeManyFrames) {
 
   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) {
@@ -189,7 +186,7 @@ TEST(WebSocketFrameParserTest, DecodePartialFrame) {
 
     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;
@@ -220,7 +217,7 @@ TEST(WebSocketFrameParserTest, DecodePartialFrame) {
 
     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;
@@ -259,7 +256,7 @@ TEST(WebSocketFrameParserTest, DecodePartialMaskedFrame) {
 
     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;
@@ -290,7 +287,7 @@ TEST(WebSocketFrameParserTest, DecodePartialMaskedFrame) {
 
     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;
@@ -327,10 +324,10 @@ TEST(WebSocketFrameParserTest, DecodeFramesOfVariousLengths) {
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
-    EXPECT_EQ(!kFrameHeaderTests[i].failed,
+    EXPECT_EQ(kFrameHeaderTests[i].error_code == WEB_SOCKET_OK,
         parser.Decode(&input.front(), input.size(), &frames));
-    EXPECT_EQ(kFrameHeaderTests[i].failed, parser.failed());
-    if (kFrameHeaderTests[i].failed) {
+    EXPECT_EQ(kFrameHeaderTests[i].error_code, parser.websocket_error());
+    if (kFrameHeaderTests[i].error_code != WEB_SOCKET_OK) {
       EXPECT_EQ(0u, frames.size());
     } else {
       EXPECT_EQ(1u, frames.size());
@@ -384,13 +381,20 @@ TEST(WebSocketFrameParserTest, DecodePartialHeader) {
     // 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;
+      bool failed = kFrameHeaderTests[i].error_code != WEB_SOCKET_OK &&
+          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].error_code == WEB_SOCKET_OK &&
+          j == last_byte_offset) {
         EXPECT_EQ(1u, frames.size());
-      else
+      } else {
         EXPECT_EQ(0u, frames.size());
+      }
     }
     if (frames.size() != 1u)
       continue;
@@ -442,15 +446,15 @@ TEST(WebSocketFrameParserTest, InvalidLengthEncoding) {
     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());
   }
 }
@@ -492,7 +496,7 @@ TEST(WebSocketFrameParserTest, FrameTypes) {
 
     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;
@@ -513,7 +517,7 @@ TEST(WebSocketFrameParserTest, FrameTypes) {
     EXPECT_EQ(opcode, header->opcode);
     EXPECT_FALSE(header->masked);
     EXPECT_EQ(0u, header->payload_length);
-  };
+  }
 }
 
 TEST(WebSocketFrameParserTest, FinalBitAndReservedBits) {
@@ -548,7 +552,7 @@ TEST(WebSocketFrameParserTest, FinalBitAndReservedBits) {
 
     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;
@@ -572,4 +576,6 @@ TEST(WebSocketFrameParserTest, FinalBitAndReservedBits) {
   }
 }
 
+}  // Unnamed namespace
+
 }  // namespace net