1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Copyright (c) 2012, Code Aurora Forum. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// HttpRequestHeaders manages the request headers.
// It maintains these in a vector of header key/value pairs, thereby maintaining
// the order of the headers. This means that any lookups are linear time
// operations.
#ifndef NET_HTTP_HTTP_REQUEST_HEADERS_H_
#define NET_HTTP_HTTP_REQUEST_HEADERS_H_
#pragma once
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/string_piece.h"
#include "net/base/net_export.h"
namespace net {
class NET_EXPORT HttpRequestHeaders {
public:
struct HeaderKeyValuePair {
HeaderKeyValuePair();
HeaderKeyValuePair(const base::StringPiece& key,
const base::StringPiece& value);
std::string key;
std::string value;
};
typedef std::vector<HeaderKeyValuePair> HeaderVector;
class Iterator {
public:
explicit Iterator(const HttpRequestHeaders& headers);
~Iterator();
// Advances the iterator to the next header, if any. Returns true if there
// is a next header. Use name() and value() methods to access the resultant
// header name and value.
bool GetNext();
// These two accessors are only valid if GetNext() returned true.
const std::string& name() const { return curr_->key; }
const std::string& value() const { return curr_->value; }
private:
bool started_;
HttpRequestHeaders::HeaderVector::const_iterator curr_;
const HttpRequestHeaders::HeaderVector::const_iterator end_;
DISALLOW_COPY_AND_ASSIGN(Iterator);
};
static const char kGetMethod[];
static const char kHeadMethod[];
static const char kAcceptCharset[];
static const char kAcceptEncoding[];
static const char kAcceptLanguage[];
static const char kCacheControl[];
static const char kConnection[];
static const char kContentType[];
static const char kCookie[];
static const char kContentLength[];
static const char kHost[];
static const char kIfModifiedSince[];
static const char kIfNoneMatch[];
static const char kIfRange[];
static const char kOrigin[];
static const char kPragma[];
static const char kProxyConnection[];
static const char kRange[];
static const char kReferer[];
static const char kUserAgent[];
static const char kTransferEncoding[];
HttpRequestHeaders();
~HttpRequestHeaders();
bool IsEmpty() const { return headers_.empty(); }
bool HasHeader(const base::StringPiece& key) const {
return FindHeader(key) != headers_.end();
}
// Gets the first header that matches |key|. If found, returns true and
// writes the value to |out|.
bool GetHeader(const base::StringPiece& key, std::string* out) const;
// Clears all the headers.
void Clear();
// Sets the header value pair for |key| and |value|. If |key| already exists,
// then the header value is modified, but the key is untouched, and the order
// in the vector remains the same. When comparing |key|, case is ignored.
void SetHeader(const base::StringPiece& key, const base::StringPiece& value);
// Sets the header value pair for |key| and |value|, if |key| does not exist.
// If |key| already exists, the call is a no-op.
// When comparing |key|, case is ignored.
void SetHeaderIfMissing(const base::StringPiece& key,
const base::StringPiece& value);
// Removes the first header that matches (case insensitive) |key|.
void RemoveHeader(const base::StringPiece& key);
// Parses the header from a string and calls SetHeader() with it. This string
// should not contain any CRLF. As per RFC2616, the format is:
//
// message-header = field-name ":" [ field-value ]
// field-name = token
// field-value = *( field-content | LWS )
// field-content = <the OCTETs making up the field-value
// and consisting of either *TEXT or combinations
// of token, separators, and quoted-string>
//
// AddHeaderFromString() will trim any LWS surrounding the
// field-content.
void AddHeaderFromString(const base::StringPiece& header_line);
// Same thing as AddHeaderFromString() except that |headers| is a "\r\n"
// delimited string of header lines. It will split up the string by "\r\n"
// and call AddHeaderFromString() on each.
void AddHeadersFromString(const base::StringPiece& headers);
// Calls SetHeader() on each header from |other|, maintaining order.
void MergeFrom(const HttpRequestHeaders& other);
// Copies from |other| to |this|.
void CopyFrom(const HttpRequestHeaders& other) {
*this = other;
}
// Serializes HttpRequestHeaders to a string representation. Joins all the
// header keys and values with ": ", and inserts "\r\n" between each header
// line, and adds the trailing "\r\n".
std::string ToString() const;
private:
HeaderVector::iterator FindHeader(const base::StringPiece& key);
HeaderVector::const_iterator FindHeader(const base::StringPiece& key) const;
HeaderVector headers_;
// Allow the copy construction and operator= to facilitate copying in
// HttpRequestInfo.
// TODO(willchan): Investigate to see if we can remove the need to copy
// HttpRequestInfo.
// DISALLOW_COPY_AND_ASSIGN(HttpRequestHeaders);
};
} // namespace net
#endif // NET_HTTP_HTTP_REQUEST_HEADERS_H_
|
