Add WebSocketFrameParser.

net/websockets/websocket_frame.h

Index: net/websockets/websocket_frame.h
diff --git a/net/websockets/websocket_frame.h b/net/websockets/websocket_frame.h
new file mode 100644
index 0000000000000000000000000000000000000000..c32b6455d08d0a08dcb2771707f0b31132ccb66b
--- /dev/null
+++ b/net/websockets/websocket_frame.h
@@ -0,0 +1,81 @@
+// 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_FRAME_H_
+#define NET_WEBSOCKETS_WEBSOCKET_FRAME_H_
+#pragma once
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/memory/ref_counted.h"
+#include "net/base/net_export.h"
+
+namespace net {
+
+// Represents a WebSocket frame header which may be shared by multiple
+// WebSocketPartialFrames.
+//
+// Members of this class correspond to each element in WebSocket frame header
+// (see http://tools.ietf.org/html/rfc6455#section-5.2).
+struct NET_EXPORT_PRIVATE WebSocketFrameHeader
+    : public base::RefCounted<WebSocketFrameHeader> {

[mmenke, 2012/05/02 16:15:41]

May be worth considering not refcounting this, just to keep think simple.  It's
a small enough structure that copying it instead isn't exactly going to impose a
huge amount of overhead, though I'm not strongly opposed to ref counting it.  Or
could modify the interface so it's not needed (Have the first frame own it, and
have the parser just have a copy of what values it needs).  I don't feel
particularly strongly about not refcounting this class, just not sure it's
needed.

If you are going to refcount this, you should give it a private destructor, and
use DISALLOW_COPY_AND_ASSIGN.  May also want to give it a constructor, and make
the fields all const, or make stored as a scoped_refptr<const> in the parser (I
didn't even realize scoped_refptr's worked with const).

[Yuta Kitamura, 2012/05/08 08:21:58]

After some consideration, I decided to not refcount this struct and go with your
suggestion ("have the first frame own it").

+  typedef int OpCode;
+  static const OpCode kOpCodeContinuation;
+  static const OpCode kOpCodeText;
+  static const OpCode kOpCodeBinary;
+  static const OpCode kOpCodeClose;
+  static const OpCode kOpCodePing;
+  static const OpCode kOpCodePong;
+
+  // These values must be a compile-time constant. "enum hack" is used here
+  // to make MSVC happy.
+  enum {
+    kBaseHeaderSize = 2,
+    kMaximumExtendedLengthSize = 8,
+    kMaskingKeyLength = 4
+  };
+
+  // Members below correspond to each item in WebSocket frame header.
+  // See <http://tools.ietf.org/html/rfc6455#section-5.2> for details.
+  bool final;
+  bool reserved1;
+  bool reserved2;
+  bool reserved3;
+  OpCode opcode;
+  bool masked;
+  uint64 payload_length;
+};
+
+// Contains payload data of a WebSocket frame.
+//
+// Payload of a WebSocket frame may be divided into multiple
+// WebSocketPartialFrame objects. You need to look at |final_part| member
+// variable to detect the end of a series of partial frame objects.
+//
+// Frame dissection is necessary to handle WebSocket frame stream containing
+// abritrarily large frames in the browser process. Because the server may send
+// a huge frame that doesn't fit in the memory, we cannot store the entire
+// payload data in the memory.
+//
+// Users of this struct should treat WebSocket frames as a data stream; it's
+// important to keep the frame data flowing, especially in the browser process.
+// Users should not let the data stuck somewhere in the pipeline.
+struct NET_EXPORT_PRIVATE WebSocketPartialFrame {

[Yuta Kitamura, 2012/05/08 08:21:58]

I'm going to rename this class to "WebSocketFrameChunk" in hope of giving better
sense of this struct.

+  WebSocketPartialFrame();
+  ~WebSocketPartialFrame();
+
+  // |header| may be shared among multiple WebSocketPartialFrames.
+  scoped_refptr<const WebSocketFrameHeader> header;
+
+  // Indicates this part is the last of partial frames.
+  bool final_part;
+
+  // |data| is always unmasked even if the frame is masked.
+  std::vector<char> data;
+};
+
+}  // namespace net
+
+#endif  // NET_WEBSOCKETS_WEBSOCKET_FRAME_H_