net/websockets/websocket_extension_parser.cc - Issue 992733002: Remove //net (except for Android test stuff) and sdch

Side by Side Diff: net/websockets/websocket_extension_parser.cc

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 // Copyright 2013 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include "net/websockets/websocket_extension_parser.h"

6

7 #include "base/strings/string_util.h"

8

9 namespace net {

10

11 WebSocketExtensionParser::WebSocketExtensionParser() {}

12

13 WebSocketExtensionParser::~WebSocketExtensionParser() {}

14

15 void WebSocketExtensionParser::Parse(const char* data, size_t size) {

16 current_ = data;

17 end_ = data + size;

18 has_error_ = false;

19

20 ConsumeExtension(&extension_);

21 if (has_error_) return;

22 ConsumeSpaces();

23 has_error_ = has_error_ \|\| (current_ != end_);

24 }

25

26 void WebSocketExtensionParser::Consume(char c) {

27 DCHECK(!has_error_);

28 ConsumeSpaces();

29 DCHECK(!has_error_);

30 if (current_ == end_ \|\| c != current_[0]) {

31 has_error_ = true;

32 return;

33 }

34 ++current_;

35 }

36

37 void WebSocketExtensionParser::ConsumeExtension(WebSocketExtension* extension) {

38 DCHECK(!has_error_);

39 base::StringPiece name;

40 ConsumeToken(&name);

41 if (has_error_) return;

42 *extension = WebSocketExtension(name.as_string());

43

44 while (ConsumeIfMatch(';')) {

45 WebSocketExtension::Parameter parameter((std::string()));

46 ConsumeExtensionParameter(&parameter);

47 if (has_error_) return;

48 extension->Add(parameter);

49 }

50 }

51

52 void WebSocketExtensionParser::ConsumeExtensionParameter(

53 WebSocketExtension::Parameter* parameter) {

54 DCHECK(!has_error_);

55 base::StringPiece name, value;

56 std::string value_string;

57

58 ConsumeToken(&name);

59 if (has_error_) return;

60 if (!ConsumeIfMatch('=')) {

61 *parameter = WebSocketExtension::Parameter(name.as_string());

62 return;

63 }

64

65 if (Lookahead('\"')) {

66 ConsumeQuotedToken(&value_string);

67 } else {

68 ConsumeToken(&value);

69 value_string = value.as_string();

70 }

71 if (has_error_) return;

72 *parameter = WebSocketExtension::Parameter(name.as_string(), value_string);

73 }

74

75 void WebSocketExtensionParser::ConsumeToken(base::StringPiece* token) {

76 DCHECK(!has_error_);

77 ConsumeSpaces();

78 DCHECK(!has_error_);

79 const char* head = current_;

80 while (current_ < end_ &&

81 !IsControl(current_[0]) && !IsSeparator(current_[0]))

82 ++current_;

83 if (current_ == head) {

84 has_error_ = true;

85 return;

86 }

87 *token = base::StringPiece(head, current_ - head);

88 }

89

90 void WebSocketExtensionParser::ConsumeQuotedToken(std::string* token) {

91 DCHECK(!has_error_);

92 Consume('"');

93 if (has_error_) return;

94 *token = "";

95 while (current_ < end_ && !IsControl(current_[0])) {

96 if (UnconsumedBytes() >= 2 && current_[0] == '\\') {

97 char next = current_[1];

98 if (IsControl(next) \|\| IsSeparator(next)) break;

99 *token += next;

100 current_ += 2;

101 } else if (IsSeparator(current_[0])) {

102 break;

103 } else {

104 *token += current_[0];

105 ++current_;

106 }

107 }

108 // We can't use Consume here because we don't want to consume spaces.

109 if (current_ < end_ && current_[0] == '"')

110 ++current_;

111 else

112 has_error_ = true;

113 has_error_ = has_error_ \|\| token->empty();

114 }

115

116 void WebSocketExtensionParser::ConsumeSpaces() {

117 DCHECK(!has_error_);

118 while (current_ < end_ && (current_[0] == ' ' \|\| current_[0] == '\t'))

119 ++current_;

120 return;

121 }

122

123 bool WebSocketExtensionParser::Lookahead(char c) {

124 DCHECK(!has_error_);

125 const char* head = current_;

126

127 Consume(c);

128 bool result = !has_error_;

129 current_ = head;

130 has_error_ = false;

131 return result;

132 }

133

134 bool WebSocketExtensionParser::ConsumeIfMatch(char c) {

135 DCHECK(!has_error_);

136 const char* head = current_;

137

138 Consume(c);

139 if (has_error_) {

140 current_ = head;

141 has_error_ = false;

142 return false;

143 }

144 return true;

145 }

146

147 // static

148 bool WebSocketExtensionParser::IsControl(char c) {

149 return (0 <= c && c <= 31) \|\| c == 127;

150 }

151

152 // static

153 bool WebSocketExtensionParser::IsSeparator(char c) {

154 const char separators[] = "()<>@,;:\\\"/[]?={} \t";

155 return strchr(separators, c) != NULL;

156 }

157

158 } // namespace net

OLD	NEW

« no previous file with comments | « net/websockets/websocket_extension_parser.h ('k') | net/websockets/websocket_extension_parser_test.cc » ('j') | no next file with comments »