Implement WebSocketExtensionParser

net/websockets/websocket_extension_parser.cc

+// Copyright 2013 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_extension_parser.h"
+
+#include "base/strings/string_util.h"
+
+namespace net {
+
+// Restore the current pointer if the parser has an error.
+class WebSocketExtensionParser::CurrentPointerBackup {

[Adam Rice, 2013/09/17 07:45:58]

Sorry my comment was not clear enough. The parser does not need backtracking, so
this class is not needed. Since this class is not needed, there is not need for
the methods for each rule to set or check the has_error_ member; they can just
return true or false. So has_error_ can go away and the code can be much
simpler.

[yhirano, 2013/09/17 09:17:39]

Done.

+ public:
+  explicit CurrentPointerBackup(WebSocketExtensionParser* parser);
+  ~CurrentPointerBackup();
+
+ private:
+  WebSocketExtensionParser* parser_;
+  const char* original_head_;
+};
+
+WebSocketExtensionParser::CurrentPointerBackup::CurrentPointerBackup(
+    WebSocketExtensionParser* parser)
+    : parser_(parser), original_head_(parser->current_) {}
+
+WebSocketExtensionParser::CurrentPointerBackup::~CurrentPointerBackup() {
+  if (parser_->has_error_)
+     parser_->current_ = original_head_;
+}
+
+WebSocketExtensionParser::WebSocketExtensionParser() {}
+
+WebSocketExtensionParser::~WebSocketExtensionParser() {}
+
+void WebSocketExtensionParser::Parse(const char* data, size_t size) {
+  current_ = data;
+  end_ = &data[size];
+  extensions_.clear();
+  has_error_ = false;
+  CurrentPointerBackup backup(this);
+
+  ConsumeExtensionList();
+  has_error_ = has_error_ || (current_ != end_);
+  if (has_error_)
+    extensions_.clear();
+}
+
+void WebSocketExtensionParser::Consume(const char* data, size_t size) {
+  DCHECK(!has_error_);
+  CurrentPointerBackup backup(this);
+  ConsumeLWS();
+  DCHECK(!has_error_);
+  if (UnconsumedBytes() < size) {
+    has_error_ = true;
+    return;
+  }
+  if (memcmp(data, current_, size)) {
+    has_error_ = true;
+    return;
+  }
+  current_ += size;
+}
+
+void WebSocketExtensionParser::ConsumeExtensionList() {

[Adam Rice, 2013/09/17 07:45:58]

We only need to parse one extension at a time, so this method is not needed.
Although the documentation for HttpResoonseHeader::EnumerateHeader is confusing,
the test at
https://code.google.com/p/chromium/codesearch#chromium/src/net/http/http_resp...
makes it clear enough that it will separate the extensions for us.

[yhirano, 2013/09/17 09:17:39]

Done.

+  DCHECK(!has_error_);
+  WebSocketExtension extension("");
+  ConsumeExtension(&extension);
+  if (has_error_) return;
+  do {
+    extensions_.push_back(extension);
+    ConsumeExtension(&extension);
+  } while (!has_error_);
+  has_error_ = false;
+}
+
+void WebSocketExtensionParser::ConsumeExtension(WebSocketExtension* extension) {
+  DCHECK(!has_error_);
+  CurrentPointerBackup backup(this);
+  base::StringPiece name;
+  ConsumeToken(&name);
+  if (has_error_) return;
+  *extension = WebSocketExtension(name.as_string());
+
+  while (ConsumeIfMatch(";", 1)) {
+    WebSocketExtension::Parameter parameter("");
+    ConsumeExtensionParameter(&parameter);
+    if (has_error_) return;
+    extension->Add(parameter);
+  }
+}
+
+void WebSocketExtensionParser::ConsumeExtensionParameter(
+    WebSocketExtension::Parameter* parameter) {
+  DCHECK(!has_error_);
+  CurrentPointerBackup backup(this);
+  base::StringPiece name, value;
+  std::string value_string;
+
+  ConsumeToken(&name);
+  if (has_error_) return;
+  if (!ConsumeIfMatch("=", 1)) {
+    *parameter = WebSocketExtension::Parameter(name.as_string());
+    return;
+  }
+
+  if (Lookahead("\"", 1)) {
+    ConsumeQuotedToken(&value_string);
+  } else {
+    ConsumeToken(&value);
+    value_string = value.as_string();
+  }
+  if (has_error_) return;
+  *parameter = WebSocketExtension::Parameter(name.as_string(), value_string);
+}
+
+void WebSocketExtensionParser::ConsumeToken(base::StringPiece* token) {
+  DCHECK(!has_error_);
+  CurrentPointerBackup backup(this);
+  ConsumeLWS();
+  DCHECK(!has_error_);
+  const char* head = current_;
+  while (current_ < end_ &&
+         !IsControl(current_[0]) && !IsSeparator(current_[0]))
+    ++current_;
+  if (current_ == head) {
+    has_error_ = true;
+    return;
+  }
+  *token = base::StringPiece(head, current_ - head);
+}
+
+void WebSocketExtensionParser::ConsumeQuotedToken(std::string* token) {
+  DCHECK(!has_error_);
+  CurrentPointerBackup backup(this);
+  Consume("\"", 1);
+  if (has_error_) return;
+  *token = "";
+  while (current_ < end_ && !IsControl(current_[0])) {
+    if (UnconsumedBytes() >= 2 && current_[0] == '\\') {
+      char next = current_[1];
+      if (IsControl(next) || IsSeparator(next)) break;
+      *token += next;
+      current_ += 2;
+    } else if (IsSeparator(current_[0])) {
+      break;
+    } else {
+      *token += current_[0];
+      ++current_;
+    }
+  }
+  Consume("\"", 1);
+  has_error_ = has_error_ || token->empty();
+}
+
+// Unlike the "implied *LWS" specification in RFC2616, this parser
+// consumes *LWS, because there are no adjacent tokens in WebSocket
+// extension grammer.
+void WebSocketExtensionParser::ConsumeLWS() {
+  DCHECK(!has_error_);
+  size_t counter = 0;
+  while (current_ < end_) {
+    if (current_[0] == ' ' || current_[0] == '\t') {
+      while (current_ < end_ && (current_[0] == ' ' || current_[0] == '\t'))
+        ++current_;
+    } else if (UnconsumedBytes() >= 3 &&
+               current_[0] == '\r' && current_[1] == '\n' &&

[Adam Rice, 2013/09/17 07:45:58]

Line coalescing is implemented by HttpResponseHeaders; no need to re-implement.

[yhirano, 2013/09/17 09:17:39]

Done.

+               (current_[2] == ' ' || current_[2] == '\t')) {
+      current_ += 2;
+      while (current_ < end_ && (current_[0] == ' ' || current_[0] == '\t'))
+        ++current_;
+      break;
+    } else {
+      break;
+    }
+    ++counter;
+  }
+  return;
+}
+
+bool WebSocketExtensionParser::Lookahead(const char* data, size_t size) {

[Adam Rice, 2013/09/17 07:45:58]

Having "size" makes this method much more complicated, but none of the callers
use it. char Lookahead() would be simpler and easier to use.

[yhirano, 2013/09/17 09:17:39]

I like this prototype because we can check an error easily.
I replaced parameters of Consume, Lookahead and ConsumeIfMatch from (const
char*, size_t) to (char).

+  DCHECK(!has_error_);
+  const char* head = current_;
+
+  ConsumeLWS();
+  if (!has_error_)
+    Consume(data, size);
+
+  bool result = !has_error_;
+  current_ = head;
+  has_error_ = false;
+  return result;
+}
+
+bool WebSocketExtensionParser::ConsumeIfMatch(const char* data, size_t size) {
+  DCHECK(!has_error_);
+  const char* head = current_;
+
+  ConsumeLWS();
+  if (!has_error_)
+    Consume(data, size);
+
+  if (has_error_) {
+    current_ = head;
+    has_error_ = false;
+    return false;
+  }
+  return true;
+}
+
+// static
+bool WebSocketExtensionParser::IsControl(char c) {
+  return (0 <= c && c <= 31) || c == 127;
+}
+
+// static
+bool WebSocketExtensionParser::IsSeparator(char c) {
+  const char separators[] = "()<>@,;:\\\"/[]?={} \t";
+  return strchr(separators, c);
+}
+
+}  // namespace net