Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(125)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: net/test/embedded_test_server/default_handlers.cc

Issue 1893083002: Change scoped_ptr to std::unique_ptr in //net. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: scopedptr-net-all: iwyu Created 4 years, 8 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
« no previous file with comments | « net/ssl/threaded_ssl_private_key.cc ('k') | net/test/embedded_test_server/embedded_test_server.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/test/embedded_test_server/default_handlers.h" 5 #include "net/test/embedded_test_server/default_handlers.h"
6 6
7 #include <stdlib.h> 7 #include <stdlib.h>
8 #include <ctime> 8 #include <ctime>
9 #include <map> 9 #include <map>
10 #include <sstream> 10 #include <sstream>
(...skipping 28 matching lines...) Expand all
39 UnescapeRule::SPOOFING_AND_CONTROL_CHARS | 39 UnescapeRule::SPOOFING_AND_CONTROL_CHARS |
40 UnescapeRule::REPLACE_PLUS_WITH_SPACE; 40 UnescapeRule::REPLACE_PLUS_WITH_SPACE;
41 41
42 const char kDefaultRealm[] = "testrealm"; 42 const char kDefaultRealm[] = "testrealm";
43 const char kDefaultPassword[] = "secret"; 43 const char kDefaultPassword[] = "secret";
44 const char kEtag[] = "abc"; 44 const char kEtag[] = "abc";
45 const char kLogoPath[] = "chrome/test/data/google/logo.gif"; 45 const char kLogoPath[] = "chrome/test/data/google/logo.gif";
46 46
47 // method: CONNECT 47 // method: CONNECT
48 // Responses with a BAD_REQUEST to any CONNECT requests. 48 // Responses with a BAD_REQUEST to any CONNECT requests.
49 scoped_ptr<HttpResponse> HandleDefaultConnect(const HttpRequest& request) { 49 std::unique_ptr<HttpResponse> HandleDefaultConnect(const HttpRequest& request) {
50 if (request.method != METHOD_CONNECT) 50 if (request.method != METHOD_CONNECT)
51 return nullptr; 51 return nullptr;
52 52
53 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 53 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
54 http_response->set_code(HTTP_BAD_REQUEST); 54 http_response->set_code(HTTP_BAD_REQUEST);
55 http_response->set_content( 55 http_response->set_content(
56 "Your client has issued a malformed or illegal request."); 56 "Your client has issued a malformed or illegal request.");
57 http_response->set_content_type("text/html"); 57 http_response->set_content_type("text/html");
58 return std::move(http_response); 58 return std::move(http_response);
59 } 59 }
60 60
61 // /cachetime 61 // /cachetime
62 // Returns a cacheable response. 62 // Returns a cacheable response.
63 scoped_ptr<HttpResponse> HandleCacheTime(const HttpRequest& request) { 63 std::unique_ptr<HttpResponse> HandleCacheTime(const HttpRequest& request) {
64 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 64 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
65 http_response->set_content( 65 http_response->set_content(
66 "<html><head><title>Cache: max-age=60</title></head></html>"); 66 "<html><head><title>Cache: max-age=60</title></head></html>");
67 http_response->set_content_type("text/html"); 67 http_response->set_content_type("text/html");
68 http_response->AddCustomHeader("Cache-Control", "max-age=60"); 68 http_response->AddCustomHeader("Cache-Control", "max-age=60");
69 return std::move(http_response); 69 return std::move(http_response);
70 } 70 }
71 71
72 // /echoheader | /echoheadercache 72 // /echoheader | /echoheadercache
73 // Responds with the headers echoed in the message body. 73 // Responds with the headers echoed in the message body.
74 // echoheader does not cache the results, while echoheadercache does. 74 // echoheader does not cache the results, while echoheadercache does.
75 scoped_ptr<HttpResponse> HandleEchoHeader(const std::string& url, 75 std::unique_ptr<HttpResponse> HandleEchoHeader(const std::string& url,
76 const std::string& cache_control, 76 const std::string& cache_control,
77 const HttpRequest& request) { 77 const HttpRequest& request) {
78 if (!ShouldHandle(request, url)) 78 if (!ShouldHandle(request, url))
79 return nullptr; 79 return nullptr;
80 80
81 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 81 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
82 82
83 GURL request_url = request.GetURL(); 83 GURL request_url = request.GetURL();
84 if (request_url.has_query()) { 84 if (request_url.has_query()) {
85 std::string header_name = request_url.query(); 85 std::string header_name = request_url.query();
86 http_response->AddCustomHeader("Vary", header_name); 86 http_response->AddCustomHeader("Vary", header_name);
87 if (request.headers.find(header_name) != request.headers.end()) 87 if (request.headers.find(header_name) != request.headers.end())
88 http_response->set_content(request.headers.at(header_name)); 88 http_response->set_content(request.headers.at(header_name));
89 else 89 else
90 http_response->set_content("None"); 90 http_response->set_content("None");
91 } 91 }
92 92
93 http_response->set_content_type("text/plain"); 93 http_response->set_content_type("text/plain");
94 http_response->AddCustomHeader("Cache-Control", cache_control); 94 http_response->AddCustomHeader("Cache-Control", cache_control);
95 return std::move(http_response); 95 return std::move(http_response);
96 } 96 }
97 97
98 // /echo?status=STATUS 98 // /echo?status=STATUS
99 // Responds with the request body as the response body and 99 // Responds with the request body as the response body and
100 // a status code of STATUS. 100 // a status code of STATUS.
101 scoped_ptr<HttpResponse> HandleEcho(const HttpRequest& request) { 101 std::unique_ptr<HttpResponse> HandleEcho(const HttpRequest& request) {
102 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 102 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
103 103
104 GURL request_url = request.GetURL(); 104 GURL request_url = request.GetURL();
105 if (request_url.has_query()) { 105 if (request_url.has_query()) {
106 RequestQuery query = ParseQuery(request_url); 106 RequestQuery query = ParseQuery(request_url);
107 if (query.find("status") != query.end()) 107 if (query.find("status") != query.end())
108 http_response->set_code(static_cast<HttpStatusCode>( 108 http_response->set_code(static_cast<HttpStatusCode>(
109 std::atoi(query["status"].front().c_str()))); 109 std::atoi(query["status"].front().c_str())));
110 } 110 }
111 111
112 http_response->set_content_type("text/html"); 112 http_response->set_content_type("text/html");
113 if (request.method != METHOD_POST && request.method != METHOD_PUT) 113 if (request.method != METHOD_POST && request.method != METHOD_PUT)
114 http_response->set_content("Echo"); 114 http_response->set_content("Echo");
115 else 115 else
116 http_response->set_content(request.content); 116 http_response->set_content(request.content);
117 return std::move(http_response); 117 return std::move(http_response);
118 } 118 }
119 119
120 // /echotitle 120 // /echotitle
121 // Responds with the request body as the title. 121 // Responds with the request body as the title.
122 scoped_ptr<HttpResponse> HandleEchoTitle(const HttpRequest& request) { 122 std::unique_ptr<HttpResponse> HandleEchoTitle(const HttpRequest& request) {
123 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 123 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
124 http_response->set_content_type("text/html"); 124 http_response->set_content_type("text/html");
125 http_response->set_content("<html><head><title>" + request.content + 125 http_response->set_content("<html><head><title>" + request.content +
126 "</title></head></html>"); 126 "</title></head></html>");
127 return std::move(http_response); 127 return std::move(http_response);
128 } 128 }
129 129
130 // /echoall?QUERY 130 // /echoall?QUERY
131 // Responds with the list of QUERY and the request headers. 131 // Responds with the list of QUERY and the request headers.
132 scoped_ptr<HttpResponse> HandleEchoAll(const HttpRequest& request) { 132 std::unique_ptr<HttpResponse> HandleEchoAll(const HttpRequest& request) {
133 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 133 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
134 134
135 std::string body = 135 std::string body =
136 "<html><head><style>" 136 "<html><head><style>"
137 "pre { border: 1px solid black; margin: 5px; padding: 5px }" 137 "pre { border: 1px solid black; margin: 5px; padding: 5px }"
138 "</style></head><body>" 138 "</style></head><body>"
139 "<div style=\"float: right\">" 139 "<div style=\"float: right\">"
140 "<a href=\"/echo\">back to referring page</a></div>" 140 "<a href=\"/echo\">back to referring page</a></div>"
141 "<h1>Request Body:</h1><pre>"; 141 "<h1>Request Body:</h1><pre>";
142 142
143 if (request.has_content) { 143 if (request.has_content) {
(...skipping 10 matching lines...) Expand all
154 "</pre>" 154 "</pre>"
155 "</body></html>"; 155 "</body></html>";
156 156
157 http_response->set_content_type("text/html"); 157 http_response->set_content_type("text/html");
158 http_response->set_content(body); 158 http_response->set_content(body);
159 return std::move(http_response); 159 return std::move(http_response);
160 } 160 }
161 161
162 // /set-cookie?COOKIES 162 // /set-cookie?COOKIES
163 // Sets response cookies to be COOKIES. 163 // Sets response cookies to be COOKIES.
164 scoped_ptr<HttpResponse> HandleSetCookie(const HttpRequest& request) { 164 std::unique_ptr<HttpResponse> HandleSetCookie(const HttpRequest& request) {
165 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 165 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
166 http_response->set_content_type("text/html"); 166 http_response->set_content_type("text/html");
167 std::string content; 167 std::string content;
168 GURL request_url = request.GetURL(); 168 GURL request_url = request.GetURL();
169 if (request_url.has_query()) { 169 if (request_url.has_query()) {
170 std::vector<std::string> cookies = base::SplitString( 170 std::vector<std::string> cookies = base::SplitString(
171 request_url.query(), "&", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); 171 request_url.query(), "&", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
172 for (const auto& cookie : cookies) { 172 for (const auto& cookie : cookies) {
173 http_response->AddCustomHeader("Set-Cookie", cookie); 173 http_response->AddCustomHeader("Set-Cookie", cookie);
174 content += cookie; 174 content += cookie;
175 } 175 }
176 } 176 }
177 177
178 http_response->set_content(content); 178 http_response->set_content(content);
179 return std::move(http_response); 179 return std::move(http_response);
180 } 180 }
181 181
182 // /set-many-cookies?N 182 // /set-many-cookies?N
183 // Sets N cookies in the response. 183 // Sets N cookies in the response.
184 scoped_ptr<HttpResponse> HandleSetManyCookies(const HttpRequest& request) { 184 std::unique_ptr<HttpResponse> HandleSetManyCookies(const HttpRequest& request) {
185 std::string content; 185 std::string content;
186 186
187 GURL request_url = request.GetURL(); 187 GURL request_url = request.GetURL();
188 size_t num = 0; 188 size_t num = 0;
189 if (request_url.has_query()) 189 if (request_url.has_query())
190 num = std::atoi(request_url.query().c_str()); 190 num = std::atoi(request_url.query().c_str());
191 191
192 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 192 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
193 http_response->set_content_type("text/html"); 193 http_response->set_content_type("text/html");
194 for (size_t i = 0; i < num; ++i) { 194 for (size_t i = 0; i < num; ++i) {
195 http_response->AddCustomHeader("Set-Cookie", "a="); 195 http_response->AddCustomHeader("Set-Cookie", "a=");
196 } 196 }
197 197
198 http_response->set_content( 198 http_response->set_content(
199 base::StringPrintf("%" PRIuS " cookies were sent", num)); 199 base::StringPrintf("%" PRIuS " cookies were sent", num));
200 return std::move(http_response); 200 return std::move(http_response);
201 } 201 }
202 202
203 // /expect-and-set-cookie?expect=EXPECTED&set=SET&data=DATA 203 // /expect-and-set-cookie?expect=EXPECTED&set=SET&data=DATA
204 // Verifies that the request cookies match EXPECTED and then returns cookies 204 // Verifies that the request cookies match EXPECTED and then returns cookies
205 // that match SET and a content that matches DATA. 205 // that match SET and a content that matches DATA.
206 scoped_ptr<HttpResponse> HandleExpectAndSetCookie(const HttpRequest& request) { 206 std::unique_ptr<HttpResponse> HandleExpectAndSetCookie(
207 const HttpRequest& request) {
207 std::vector<std::string> received_cookies; 208 std::vector<std::string> received_cookies;
208 if (request.headers.find("Cookie") != request.headers.end()) { 209 if (request.headers.find("Cookie") != request.headers.end()) {
209 received_cookies = 210 received_cookies =
210 base::SplitString(request.headers.at("Cookie"), ";", 211 base::SplitString(request.headers.at("Cookie"), ";",
211 base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL); 212 base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
212 } 213 }
213 214
214 bool got_all_expected = true; 215 bool got_all_expected = true;
215 GURL request_url = request.GetURL(); 216 GURL request_url = request.GetURL();
216 RequestQuery query_list = ParseQuery(request_url); 217 RequestQuery query_list = ParseQuery(request_url);
217 if (query_list.find("expect") != query_list.end()) { 218 if (query_list.find("expect") != query_list.end()) {
218 for (const auto& expected_cookie : query_list.at("expect")) { 219 for (const auto& expected_cookie : query_list.at("expect")) {
219 bool found = false; 220 bool found = false;
220 for (const auto& received_cookie : received_cookies) { 221 for (const auto& received_cookie : received_cookies) {
221 if (expected_cookie == received_cookie) 222 if (expected_cookie == received_cookie)
222 found = true; 223 found = true;
223 } 224 }
224 got_all_expected &= found; 225 got_all_expected &= found;
225 } 226 }
226 } 227 }
227 228
228 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 229 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
229 http_response->set_content_type("text/html"); 230 http_response->set_content_type("text/html");
230 if (got_all_expected) { 231 if (got_all_expected) {
231 for (const auto& cookie : query_list.at("set")) { 232 for (const auto& cookie : query_list.at("set")) {
232 http_response->AddCustomHeader( 233 http_response->AddCustomHeader(
233 "Set-Cookie", net::UnescapeURLComponent(cookie, kUnescapeAll)); 234 "Set-Cookie", net::UnescapeURLComponent(cookie, kUnescapeAll));
234 } 235 }
235 } 236 }
236 237
237 std::string content; 238 std::string content;
238 if (query_list.find("data") != query_list.end()) { 239 if (query_list.find("data") != query_list.end()) {
239 for (const auto& item : query_list.at("data")) 240 for (const auto& item : query_list.at("data"))
240 content += item; 241 content += item;
241 } 242 }
242 243
243 http_response->set_content(content); 244 http_response->set_content(content);
244 return std::move(http_response); 245 return std::move(http_response);
245 } 246 }
246 247
247 // /set-header?HEADERS 248 // /set-header?HEADERS
248 // Returns a response with HEADERS set as the response headers. 249 // Returns a response with HEADERS set as the response headers.
249 scoped_ptr<HttpResponse> HandleSetHeader(const HttpRequest& request) { 250 std::unique_ptr<HttpResponse> HandleSetHeader(const HttpRequest& request) {
250 std::string content; 251 std::string content;
251 252
252 GURL request_url = request.GetURL(); 253 GURL request_url = request.GetURL();
253 254
254 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 255 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
255 http_response->set_content_type("text/html"); 256 http_response->set_content_type("text/html");
256 if (request_url.has_query()) { 257 if (request_url.has_query()) {
257 RequestQuery headers = ParseQuery(request_url); 258 RequestQuery headers = ParseQuery(request_url);
258 for (const auto& header : headers) { 259 for (const auto& header : headers) {
259 size_t delimiter = header.first.find(": "); 260 size_t delimiter = header.first.find(": ");
260 if (delimiter == std::string::npos) 261 if (delimiter == std::string::npos)
261 continue; 262 continue;
262 std::string key = header.first.substr(0, delimiter); 263 std::string key = header.first.substr(0, delimiter);
263 std::string value = header.first.substr(delimiter + 2); 264 std::string value = header.first.substr(delimiter + 2);
264 http_response->AddCustomHeader(key, value); 265 http_response->AddCustomHeader(key, value);
265 content += header.first; 266 content += header.first;
266 } 267 }
267 } 268 }
268 269
269 http_response->set_content(content); 270 http_response->set_content(content);
270 return std::move(http_response); 271 return std::move(http_response);
271 } 272 }
272 273
273 // /nocontent 274 // /nocontent
274 // Returns a NO_CONTENT response. 275 // Returns a NO_CONTENT response.
275 scoped_ptr<HttpResponse> HandleNoContent(const HttpRequest& request) { 276 std::unique_ptr<HttpResponse> HandleNoContent(const HttpRequest& request) {
276 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 277 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
277 http_response->set_code(HTTP_NO_CONTENT); 278 http_response->set_code(HTTP_NO_CONTENT);
278 return std::move(http_response); 279 return std::move(http_response);
279 } 280 }
280 281
281 // /close-socket 282 // /close-socket
282 // Immediately closes the connection. 283 // Immediately closes the connection.
283 scoped_ptr<HttpResponse> HandleCloseSocket(const HttpRequest& request) { 284 std::unique_ptr<HttpResponse> HandleCloseSocket(const HttpRequest& request) {
284 scoped_ptr<RawHttpResponse> http_response(new RawHttpResponse("", "")); 285 std::unique_ptr<RawHttpResponse> http_response(new RawHttpResponse("", ""));
285 return std::move(http_response); 286 return std::move(http_response);
286 } 287 }
287 288
288 // /auth-basic?password=PASS&realm=REALM 289 // /auth-basic?password=PASS&realm=REALM
289 // Performs "Basic" HTTP authentication using expected password PASS and 290 // Performs "Basic" HTTP authentication using expected password PASS and
290 // realm REALM. 291 // realm REALM.
291 scoped_ptr<HttpResponse> HandleAuthBasic(const HttpRequest& request) { 292 std::unique_ptr<HttpResponse> HandleAuthBasic(const HttpRequest& request) {
292 GURL request_url = request.GetURL(); 293 GURL request_url = request.GetURL();
293 RequestQuery query = ParseQuery(request_url); 294 RequestQuery query = ParseQuery(request_url);
294 295
295 std::string expected_password = kDefaultPassword; 296 std::string expected_password = kDefaultPassword;
296 if (query.find("password") != query.end()) 297 if (query.find("password") != query.end())
297 expected_password = query.at("password").front(); 298 expected_password = query.at("password").front();
298 std::string realm = kDefaultRealm; 299 std::string realm = kDefaultRealm;
299 if (query.find("realm") != query.end()) 300 if (query.find("realm") != query.end())
300 realm = query.at("realm").front(); 301 realm = query.at("realm").front();
301 302
(...skipping 20 matching lines...) Expand all
322 if (password == expected_password) 323 if (password == expected_password)
323 authed = true; 324 authed = true;
324 else 325 else
325 error = "Invalid Credentials"; 326 error = "Invalid Credentials";
326 } else { 327 } else {
327 error = "Invalid Credentials"; 328 error = "Invalid Credentials";
328 } 329 }
329 } 330 }
330 } 331 }
331 332
332 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 333 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
333 if (!authed) { 334 if (!authed) {
334 http_response->set_code(HTTP_UNAUTHORIZED); 335 http_response->set_code(HTTP_UNAUTHORIZED);
335 http_response->set_content_type("text/html"); 336 http_response->set_content_type("text/html");
336 http_response->AddCustomHeader("WWW-Authenticate", 337 http_response->AddCustomHeader("WWW-Authenticate",
337 "Basic realm=\"" + realm + "\""); 338 "Basic realm=\"" + realm + "\"");
338 if (query.find("set-cookie-if-challenged") != query.end()) 339 if (query.find("set-cookie-if-challenged") != query.end())
339 http_response->AddCustomHeader("Set-Cookie", "got_challenged=true"); 340 http_response->AddCustomHeader("Set-Cookie", "got_challenged=true");
340 http_response->set_content(base::StringPrintf( 341 http_response->set_content(base::StringPrintf(
341 "<html><head><title>Denied: %s</title></head>" 342 "<html><head><title>Denied: %s</title></head>"
342 "<body>auth=%s<p>b64str=%s<p>username: %s<p>userpass: %s<p>" 343 "<body>auth=%s<p>b64str=%s<p>username: %s<p>userpass: %s<p>"
(...skipping 28 matching lines...) Expand all
371 request.all_headers.c_str())); 372 request.all_headers.c_str()));
372 } 373 }
373 374
374 http_response->AddCustomHeader("Cache-Control", "max-age=60000"); 375 http_response->AddCustomHeader("Cache-Control", "max-age=60000");
375 http_response->AddCustomHeader("Etag", kEtag); 376 http_response->AddCustomHeader("Etag", kEtag);
376 return std::move(http_response); 377 return std::move(http_response);
377 } 378 }
378 379
379 // /auth-digest 380 // /auth-digest
380 // Performs "Digest" HTTP authentication. 381 // Performs "Digest" HTTP authentication.
381 scoped_ptr<HttpResponse> HandleAuthDigest(const HttpRequest& request) { 382 std::unique_ptr<HttpResponse> HandleAuthDigest(const HttpRequest& request) {
382 std::string nonce = base::MD5String( 383 std::string nonce = base::MD5String(
383 base::StringPrintf("privatekey%s", request.relative_url.c_str())); 384 base::StringPrintf("privatekey%s", request.relative_url.c_str()));
384 std::string opaque = base::MD5String("opaque"); 385 std::string opaque = base::MD5String("opaque");
385 std::string password = kDefaultPassword; 386 std::string password = kDefaultPassword;
386 std::string realm = kDefaultRealm; 387 std::string realm = kDefaultRealm;
387 388
388 bool authed = false; 389 bool authed = false;
389 std::string error; 390 std::string error;
390 std::string auth; 391 std::string auth;
391 std::string digest_str = "Digest"; 392 std::string digest_str = "Digest";
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after
439 "%s:%s:%s", hash1.c_str(), nonce.c_str(), hash2.c_str())); 440 "%s:%s:%s", hash1.c_str(), nonce.c_str(), hash2.c_str()));
440 } 441 }
441 442
442 if (auth_pairs["response"] == response) 443 if (auth_pairs["response"] == response)
443 authed = true; 444 authed = true;
444 else 445 else
445 error = "wrong password"; 446 error = "wrong password";
446 } 447 }
447 } 448 }
448 449
449 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 450 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
450 if (!authed) { 451 if (!authed) {
451 http_response->set_code(HTTP_UNAUTHORIZED); 452 http_response->set_code(HTTP_UNAUTHORIZED);
452 http_response->set_content_type("text/html"); 453 http_response->set_content_type("text/html");
453 std::string auth_header = base::StringPrintf( 454 std::string auth_header = base::StringPrintf(
454 "Digest realm=\"%s\", " 455 "Digest realm=\"%s\", "
455 "domain=\"/\", qop=\"auth\", algorithm=MD5, nonce=\"%s\", " 456 "domain=\"/\", qop=\"auth\", algorithm=MD5, nonce=\"%s\", "
456 "opaque=\"%s\"", 457 "opaque=\"%s\"",
457 realm.c_str(), nonce.c_str(), opaque.c_str()); 458 realm.c_str(), nonce.c_str(), opaque.c_str());
458 http_response->AddCustomHeader("WWW-Authenticate", auth_header); 459 http_response->AddCustomHeader("WWW-Authenticate", auth_header);
459 http_response->set_content(base::StringPrintf( 460 http_response->set_content(base::StringPrintf(
460 "<html><head><title>Denied: %s</title></head>" 461 "<html><head><title>Denied: %s</title></head>"
461 "<body>auth=%s<p>" 462 "<body>auth=%s<p>"
462 "You sent:<br>%s<p>We are replying:<br>%s<p></body></html>", 463 "You sent:<br>%s<p>We are replying:<br>%s<p></body></html>",
463 error.c_str(), auth.c_str(), request.all_headers.c_str(), 464 error.c_str(), auth.c_str(), request.all_headers.c_str(),
464 auth_header.c_str())); 465 auth_header.c_str()));
465 return std::move(http_response); 466 return std::move(http_response);
466 } 467 }
467 468
468 http_response->set_content_type("text/html"); 469 http_response->set_content_type("text/html");
469 http_response->set_content( 470 http_response->set_content(
470 base::StringPrintf("<html><head><title>%s/%s</title></head>" 471 base::StringPrintf("<html><head><title>%s/%s</title></head>"
471 "<body>auth=%s<p></body></html>", 472 "<body>auth=%s<p></body></html>",
472 username.c_str(), password.c_str(), auth.c_str())); 473 username.c_str(), password.c_str(), auth.c_str()));
473 474
474 return std::move(http_response); 475 return std::move(http_response);
475 } 476 }
476 477
477 // /server-redirect?URL 478 // /server-redirect?URL
478 // Returns a server-redirect (301) to URL. 479 // Returns a server-redirect (301) to URL.
479 scoped_ptr<HttpResponse> HandleServerRedirect(const HttpRequest& request) { 480 std::unique_ptr<HttpResponse> HandleServerRedirect(const HttpRequest& request) {
480 GURL request_url = request.GetURL(); 481 GURL request_url = request.GetURL();
481 std::string dest = 482 std::string dest =
482 net::UnescapeURLComponent(request_url.query(), kUnescapeAll); 483 net::UnescapeURLComponent(request_url.query(), kUnescapeAll);
483 484
484 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 485 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
485 http_response->set_code(HTTP_MOVED_PERMANENTLY); 486 http_response->set_code(HTTP_MOVED_PERMANENTLY);
486 http_response->AddCustomHeader("Location", dest); 487 http_response->AddCustomHeader("Location", dest);
487 http_response->set_content_type("text/html"); 488 http_response->set_content_type("text/html");
488 http_response->set_content(base::StringPrintf( 489 http_response->set_content(base::StringPrintf(
489 "<html><head></head><body>Redirecting to %s</body></html>", 490 "<html><head></head><body>Redirecting to %s</body></html>",
490 dest.c_str())); 491 dest.c_str()));
491 return std::move(http_response); 492 return std::move(http_response);
492 } 493 }
493 494
494 // /cross-site?URL 495 // /cross-site?URL
495 // Returns a cross-site redirect to URL. 496 // Returns a cross-site redirect to URL.
496 scoped_ptr<HttpResponse> HandleCrossSiteRedirect(EmbeddedTestServer* server, 497 std::unique_ptr<HttpResponse> HandleCrossSiteRedirect(
497 const HttpRequest& request) { 498 EmbeddedTestServer* server,
499 const HttpRequest& request) {
498 if (!ShouldHandle(request, "/cross-site")) 500 if (!ShouldHandle(request, "/cross-site"))
499 return nullptr; 501 return nullptr;
500 502
501 std::string dest_all = net::UnescapeURLComponent( 503 std::string dest_all = net::UnescapeURLComponent(
502 request.relative_url.substr(std::string("/cross-site").size() + 1), 504 request.relative_url.substr(std::string("/cross-site").size() + 1),
503 kUnescapeAll); 505 kUnescapeAll);
504 506
505 std::string dest; 507 std::string dest;
506 size_t delimiter = dest_all.find("/"); 508 size_t delimiter = dest_all.find("/");
507 if (delimiter != std::string::npos) { 509 if (delimiter != std::string::npos) {
508 dest = base::StringPrintf( 510 dest = base::StringPrintf(
509 "//%s:%hu/%s", dest_all.substr(0, delimiter).c_str(), server->port(), 511 "//%s:%hu/%s", dest_all.substr(0, delimiter).c_str(), server->port(),
510 dest_all.substr(delimiter + 1).c_str()); 512 dest_all.substr(delimiter + 1).c_str());
511 } 513 }
512 514
513 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 515 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
514 http_response->set_code(HTTP_MOVED_PERMANENTLY); 516 http_response->set_code(HTTP_MOVED_PERMANENTLY);
515 http_response->AddCustomHeader("Location", dest); 517 http_response->AddCustomHeader("Location", dest);
516 http_response->set_content_type("text/html"); 518 http_response->set_content_type("text/html");
517 http_response->set_content(base::StringPrintf( 519 http_response->set_content(base::StringPrintf(
518 "<html><head></head><body>Redirecting to %s</body></html>", 520 "<html><head></head><body>Redirecting to %s</body></html>",
519 dest.c_str())); 521 dest.c_str()));
520 return std::move(http_response); 522 return std::move(http_response);
521 } 523 }
522 524
523 // /client-redirect?URL 525 // /client-redirect?URL
524 // Returns a meta redirect to URL. 526 // Returns a meta redirect to URL.
525 scoped_ptr<HttpResponse> HandleClientRedirect(const HttpRequest& request) { 527 std::unique_ptr<HttpResponse> HandleClientRedirect(const HttpRequest& request) {
526 GURL request_url = request.GetURL(); 528 GURL request_url = request.GetURL();
527 std::string dest = 529 std::string dest =
528 net::UnescapeURLComponent(request_url.query(), kUnescapeAll); 530 net::UnescapeURLComponent(request_url.query(), kUnescapeAll);
529 531
530 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 532 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
531 http_response->set_content_type("text/html"); 533 http_response->set_content_type("text/html");
532 http_response->set_content(base::StringPrintf( 534 http_response->set_content(base::StringPrintf(
533 "<html><head><meta http-equiv=\"refresh\" content=\"0;url=%s\"></head>" 535 "<html><head><meta http-equiv=\"refresh\" content=\"0;url=%s\"></head>"
534 "<body>Redirecting to %s</body></html>", 536 "<body>Redirecting to %s</body></html>",
535 dest.c_str(), dest.c_str())); 537 dest.c_str(), dest.c_str()));
536 return std::move(http_response); 538 return std::move(http_response);
537 } 539 }
538 540
539 // /defaultresponse 541 // /defaultresponse
540 // Returns a valid 200 response. 542 // Returns a valid 200 response.
541 scoped_ptr<HttpResponse> HandleDefaultResponse(const HttpRequest& request) { 543 std::unique_ptr<HttpResponse> HandleDefaultResponse(
542 scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse); 544 const HttpRequest& request) {
545 std::unique_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
543 http_response->set_content_type("text/html"); 546 http_response->set_content_type("text/html");
544 http_response->set_content("Default response given for path: " + 547 http_response->set_content("Default response given for path: " +
545 request.relative_url); 548 request.relative_url);
546 return std::move(http_response); 549 return std::move(http_response);
547 } 550 }
548 551
549 // Delays |delay| seconds before sending a response to the client. 552 // Delays |delay| seconds before sending a response to the client.
550 class DelayedHttpResponse : public BasicHttpResponse { 553 class DelayedHttpResponse : public BasicHttpResponse {
551 public: 554 public:
552 explicit DelayedHttpResponse(double delay) : delay_(delay) {} 555 explicit DelayedHttpResponse(double delay) : delay_(delay) {}
553 556
554 void SendResponse(const SendBytesCallback& send, 557 void SendResponse(const SendBytesCallback& send,
555 const SendCompleteCallback& done) override { 558 const SendCompleteCallback& done) override {
556 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( 559 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
557 FROM_HERE, base::Bind(send, ToResponseString(), done), 560 FROM_HERE, base::Bind(send, ToResponseString(), done),
558 base::TimeDelta::FromSecondsD(delay_)); 561 base::TimeDelta::FromSecondsD(delay_));
559 } 562 }
560 563
561 private: 564 private:
562 const double delay_; 565 const double delay_;
563 566
564 DISALLOW_COPY_AND_ASSIGN(DelayedHttpResponse); 567 DISALLOW_COPY_AND_ASSIGN(DelayedHttpResponse);
565 }; 568 };
566 569
567 // /slow?N 570 // /slow?N
568 // Returns a response to the server delayed by N seconds. 571 // Returns a response to the server delayed by N seconds.
569 scoped_ptr<HttpResponse> HandleSlowServer(const HttpRequest& request) { 572 std::unique_ptr<HttpResponse> HandleSlowServer(const HttpRequest& request) {
570 double delay = 1.0f; 573 double delay = 1.0f;
571 574
572 GURL request_url = request.GetURL(); 575 GURL request_url = request.GetURL();
573 if (request_url.has_query()) 576 if (request_url.has_query())
574 delay = std::atof(request_url.query().c_str()); 577 delay = std::atof(request_url.query().c_str());
575 578
576 scoped_ptr<BasicHttpResponse> http_response(new DelayedHttpResponse(delay)); 579 std::unique_ptr<BasicHttpResponse> http_response(
580 new DelayedHttpResponse(delay));
577 http_response->set_content_type("text/plain"); 581 http_response->set_content_type("text/plain");
578 http_response->set_content(base::StringPrintf("waited %.1f seconds", delay)); 582 http_response->set_content(base::StringPrintf("waited %.1f seconds", delay));
579 return std::move(http_response); 583 return std::move(http_response);
580 } 584 }
581 585
582 } // namespace anonymous 586 } // namespace anonymous
583 587
584 #define PREFIXED_HANDLER(prefix, handler) \ 588 #define PREFIXED_HANDLER(prefix, handler) \
585 base::Bind(&HandlePrefixedRequest, prefix, base::Bind(handler)) 589 base::Bind(&HandlePrefixedRequest, prefix, base::Bind(handler))
586 590
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
631 // TODO(svaldez): HandleGetChannelID 635 // TODO(svaldez): HandleGetChannelID
632 // TODO(svaldez): HandleGetClientCert 636 // TODO(svaldez): HandleGetClientCert
633 // TODO(svaldez): HandleClientCipherList 637 // TODO(svaldez): HandleClientCipherList
634 // TODO(svaldez): HandleEchoMultipartPost 638 // TODO(svaldez): HandleEchoMultipartPost
635 } 639 }
636 640
637 #undef PREFIXED_HANDLER 641 #undef PREFIXED_HANDLER
638 642
639 } // namespace test_server 643 } // namespace test_server
640 } // namespace net 644 } // namespace net
OLDNEW
« no previous file with comments | « net/ssl/threaded_ssl_private_key.cc ('k') | net/test/embedded_test_server/embedded_test_server.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698