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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/test/embedded_test_server/default_handlers.cc

Issue 1406313002: Adding Default Handlers from SpawnedTestServer to EmbeddedTestServer (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@ets
Patch Set: Rebase. Created 5 years, 2 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 side-by-side diff with in-line comments
Download patch
« net/test/embedded_test_server/default_handlers.h ('K') | « net/test/embedded_test_server/default_handlers.h ('k') | net/test/embedded_test_server/embedded_test_server.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/test/embedded_test_server/default_handlers.cc
diff --git a/net/test/embedded_test_server/default_handlers.cc b/net/test/embedded_test_server/default_handlers.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6f058f874f83a6f82dba2d4d6b2f57cb9f7a874b
--- /dev/null
+++ b/net/test/embedded_test_server/default_handlers.cc
@@ -0,0 +1,600 @@
+// Copyright 2015 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/test/embedded_test_server/default_handlers.h"
+
+#include <stdlib.h>
+#include <ctime>
+#include <map>
+#include <sstream>
+#include <string>
+
+#include "base/base64.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/format_macros.h"
+#include "base/md5.h"
+#include "base/path_service.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/time/time.h"
+#include "net/base/escape.h"
+#include "net/base/url_util.h"
+#include "net/test/embedded_test_server/http_request.h"
+#include "net/test/embedded_test_server/http_response.h"
+#include "net/test/embedded_test_server/request_handler_util.h"
+
+namespace net {
+namespace test_server {
+namespace {
+
+#define PREFIXED_HANDLER(prefix, handler) \
Bence 2015/10/27 14:47:36 And #undef PREFIXED_HANDLER shortly after last use
Bence 2015/10/27 14:47:36 Move this down to around line 548, like right befo
svaldez 2015/10/27 15:00:50 Done.
svaldez 2015/10/27 15:00:50 Done.
+ base::Bind(&HandlePrefixedRequest, prefix, base::Bind(handler))
+
+const UnescapeRule::Type kUnescapeAll =
+ UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS |
+ UnescapeRule::SPOOFING_AND_CONTROL_CHARS |
+ UnescapeRule::REPLACE_PLUS_WITH_SPACE;
+
+const char kDefaultRealm[] = "testrealm";
+const char kDefaultPassword[] = "password";
+
+scoped_ptr<HttpResponse> HandleDefaultConnect(const HttpRequest& request) {
+ if (request.method != METHOD_CONNECT)
+ return nullptr;
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_BAD_REQUEST);
+ http_response->set_content(
+ "Your client has issued a malformed or illegal request.");
+ http_response->set_content_type("text/html");
+ return http_response.Pass();
Bence 2015/10/27 14:47:36 Please consider removing Pass() from every return
svaldez 2015/10/27 15:00:50 There currently needs to be an explicit Pass() sin
Bence 2015/10/27 15:13:19 Sorry, I didn't realize that.
+}
+
+scoped_ptr<HttpResponse> HandleCacheTime(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content(
+ "<html><head><title>Cache: max-age=60</title></head></html>");
+ http_response->set_content_type("text/html");
+ http_response->AddCustomHeader("Cache-Control", "max-age=60");
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleEchoHeader(std::string url,
+ std::string cache_control,
+ const HttpRequest& request) {
+ if (!ShouldHandle(request, url))
+ return nullptr;
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+
+ GURL request_gurl = request.GetURL();
+ if (request_gurl.has_query()) {
+ std::string header_name = request_gurl.query();
+ http_response->AddCustomHeader("Vary", header_name);
+ if (request.headers.find(header_name) != request.headers.end())
+ http_response->set_content(request.headers.at(header_name));
+ else
+ http_response->set_content("None");
+ }
+
+ http_response->set_content_type("text/plain");
+ http_response->AddCustomHeader("Cache-Control", cache_control);
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleEcho(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+
+ GURL request_gurl = request.GetURL();
+ if (request_gurl.has_query()) {
+ RequestQuery query = ParseQuery(request_gurl);
+ if (query.find("status") != query.end())
+ http_response->set_code(static_cast<HttpStatusCode>(
+ std::atoi(query["status"].front().c_str())));
+ }
+
+ http_response->set_content_type("text/html");
+ if (request.method != METHOD_POST && request.method != METHOD_PUT)
+ http_response->set_content("Echo");
+ else
+ http_response->set_content(request.content);
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleEchoTitle(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/html");
+ http_response->set_content("<html><head><title>" + request.content +
+ "</title></head></html>");
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleEchoAll(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+
+ std::string body;
+ body +=
+ "<html><head><style>"
+ "pre { border: 1px solid black; margin: 5px; padding: 5px }"
+ "</style></head><body>"
+ "<div style=\"float: right\">"
+ "<a href=\"/echo\">back to referring page</a></div>"
+ "<h1>Request Body:</h1><pre>";
+
+ if (request.has_content) {
+ std::vector<std::string> qs = base::SplitString(
+ request.content, "&", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+ for (size_t i = 0; i < qs.size(); ++i) {
+ body += qs[i] + "\n";
+ }
+ }
+
+ body +=
+ "</pre>"
+ "<h1>Request Headers:</h1><pre>" +
+ request.all_headers +
+ "</pre>"
+ "</body></html>";
+
+ http_response->set_content_type("text/html");
+ http_response->set_content(body);
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleSetCookie(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/html");
+ std::string content;
+ GURL request_gurl = request.GetURL();
+ if (request_gurl.has_query()) {
+ std::vector<std::string> cookies = base::SplitString(
+ request_gurl.query(), "&", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+ for (size_t i = 0; i < cookies.size(); ++i) {
+ http_response->AddCustomHeader("Set-Cookie", cookies[i]);
+ content += cookies[i];
+ }
+ }
+
+ http_response->set_content(content);
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleSetManyCookies(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/html");
+ std::string content;
+
+ GURL request_gurl = request.GetURL();
+ size_t num = 0;
+ if (request_gurl.has_query()) {
+ num = std::atoi(request_gurl.query().c_str());
+ }
+
+ for (size_t i = 0; i < num; ++i) {
+ http_response->AddCustomHeader("Set-Cookie", "a=");
+ }
+
+ http_response->set_content(
+ base::StringPrintf("%" PRIuS " cookies were sent", num));
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleExpectAndSetCookie(const HttpRequest& request) {
+ std::vector<std::string> sentCookies;
+ if (request.headers.find("Cookie") != request.headers.end()) {
+ std::vector<std::string> cookies =
+ base::SplitString(request.headers.at("Cookie"), ";",
+ base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+ for (size_t i = 0; i < cookies.size(); ++i) {
+ sentCookies.push_back(cookies[i]);
+ }
+ }
+ bool gotExpected = true;
+
+ GURL request_gurl = request.GetURL();
+ RequestQuery qs = ParseQuery(request_gurl);
+ if (qs.find("expect") != qs.end()) {
+ std::vector<std::string> expected = qs.at("expect");
+ for (size_t i = 0; i < expected.size(); ++i) {
+ bool found = false;
+ for (size_t j = 0; j < sentCookies.size(); ++j) {
+ if (expected[i] == sentCookies[j])
+ found = true;
+ }
+ gotExpected &= found;
+ }
+ }
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/html");
+ if (gotExpected) {
+ std::vector<std::string> setCookies = qs.at("set");
+ for (size_t i = 0; i < setCookies.size(); ++i) {
+ http_response->AddCustomHeader(
+ "Set-Cookie", net::UnescapeURLComponent(setCookies[i], kUnescapeAll));
+ }
+ }
+
+ std::string content;
+ if (qs.find("data") != qs.end()) {
+ std::vector<std::string> data = qs.at("data");
+ for (size_t i = 0; i < data.size(); ++i) {
+ content += data[i];
+ }
+ }
+
+ http_response->set_content(content);
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleSetHeader(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/html");
+
+ std::string content;
+
+ GURL request_gurl = request.GetURL();
+ if (request_gurl.has_query()) {
+ RequestQuery headers = ParseQuery(request_gurl);
+ for (auto header : headers) {
+ std::string key = header.first.substr(0, header.first.find(": "));
+ std::string value = header.first.substr(header.first.find(": ") + 2);
+ http_response->AddCustomHeader(key, value);
+ content += header.first;
+ }
+ }
+
+ http_response->set_content(content);
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleNoContent(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_NO_CONTENT);
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleCloseSocket(const HttpRequest& request) {
+ scoped_ptr<RawHttpResponse> http_response(new RawHttpResponse("", ""));
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleAuthBasic(const HttpRequest& request) {
+ GURL request_gurl = request.GetURL();
+ RequestQuery query = ParseQuery(request_gurl);
+
+ std::string expectedPassword = "secret";
+ if (query.find(kDefaultPassword) != query.end())
+ expectedPassword = query.at(kDefaultPassword).front();
+ std::string realm = kDefaultRealm;
+ if (query.find("realm") != query.end())
+ realm = query.at("realm").front();
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ bool authed = false;
+ std::string error;
+ std::string auth;
+ std::string username;
+ std::string userpass;
+ std::string password;
+ std::string b64str;
+ if (request.headers.find("Authorization") == request.headers.end()) {
+ error = "Missing Authorization Header";
+ } else {
+ auth = request.headers.at("Authorization");
+ if (auth.find("Basic ") == std::string::npos) {
+ error = "Invalid Authorization Header";
+ } else {
+ b64str = auth.substr(std::string("Basic ").size());
+ base::Base64Decode(b64str, &userpass);
+ if (userpass.find(":") != std::string::npos) {
+ username = userpass.substr(0, userpass.find(":"));
+ password = userpass.substr(userpass.find(":") + 1);
+ if (password == expectedPassword)
+ authed = true;
+ else
+ error = "Invalid Credentials";
+ } else
+ error = "Invalid Credentials";
+ }
+ }
+
+ if (!authed) {
+ http_response->set_code(HTTP_UNAUTHORIZED);
+ http_response->set_content_type("text/html");
+ http_response->AddCustomHeader("WWW-Authenticate",
+ "Basic realm=\"" + realm + "\"");
+ if (query.find("set-cookie-if-challenged") != query.end())
+ http_response->AddCustomHeader("Set-Cookie", "got_challenged=true");
+ http_response->set_content(base::StringPrintf(
+ "<html><head><title>Denied: %s</title></head>"
+ "<body>auth=%s<p>b64str=%s<p>username: %s<p>userpass: %s<p>"
+ "password: %s<p>You sent:<br>%s<p></body></html>",
+ error.c_str(), auth.c_str(), b64str.c_str(), username.c_str(),
+ userpass.c_str(), password.c_str(), request.all_headers.c_str()));
+ return http_response.Pass();
+ }
+
+ if (request.headers.find("If-None-Match") != request.headers.end() &&
+ request.headers.at("If-None-Match") == "abc") {
+ http_response->set_code(HTTP_NOT_MODIFIED);
+ return http_response.Pass();
+ }
+
+ base::FilePath file_path =
+ base::FilePath().AppendASCII(request.relative_url.substr(1));
+ if (file_path.FinalExtension() == FILE_PATH_LITERAL("gif")) {
+ base::FilePath server_root;
+ PathService::Get(base::DIR_SOURCE_ROOT, &server_root);
+ base::FilePath gif_path =
+ server_root.AppendASCII("chrome/test/data/google/logo.gif");
+ std::string gif_data;
+ base::ReadFileToString(gif_path, &gif_data);
+ http_response->set_content_type("image/gif");
+ http_response->set_content(gif_data);
+ } else {
+ http_response->set_content_type("text/html");
+ http_response->set_content(
+ base::StringPrintf("<html><head><title>%s/%s</title></head>"
+ "<body>auth=%s<p>You sent:<br>%s<p></body></html>",
+ username.c_str(), password.c_str(), auth.c_str(),
+ request.all_headers.c_str()));
+ }
+
+ http_response->set_code(HTTP_OK);
+ http_response->AddCustomHeader("Cache-Control", "max-age=60000");
+ http_response->AddCustomHeader("Etag", "abc");
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleAuthDigest(const HttpRequest& request) {
+ std::string nonce = base::MD5String(
+ base::StringPrintf("privatekey%s", request.relative_url.c_str()));
+ std::string opaque = base::MD5String("opaque");
+ std::string password = "secret";
+ std::string realm = kDefaultRealm;
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ bool authed = false;
+ std::string error;
+ std::string auth;
+ std::string digestStr = "Digest";
+ std::string username;
+ if (request.headers.find("Authorization") == request.headers.end()) {
+ error = "no auth";
+ } else if (request.headers.at("Authorization").substr(0, digestStr.size()) !=
+ digestStr) {
+ error = "not digest";
+ } else {
+ auth = request.headers.at("Authorization");
+
+ std::map<std::string, std::string> authPairs;
+ std::vector<std::string> authVector = base::SplitString(
+ auth, ", ", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
+ for (auto authPair : authVector) {
+ std::string key = authPair.substr(0, authPair.find("="));
+ std::string value = authPair.substr(authPair.find("=") + 1);
+ if (value.substr(0, 1) == "\"" && value.substr(value.size() - 1) == "\"")
+ value = value.substr(1, value.size() - 2);
+ authPairs[key] = value;
+ }
+
+ if (authPairs["nonce"] != nonce) {
+ error = "wrong nonce";
+ } else if (authPairs["opaque"] != opaque) {
+ error = "wrong opaque";
+ } else {
+ username = authPairs["username"];
+
+ std::string hash1 = base::MD5String(
+ base::StringPrintf("%s:%s:%s", authPairs["username"].c_str(),
+ realm.c_str(), password.c_str()));
+ std::string hash2 = base::MD5String(base::StringPrintf(
+ "%s:%s", request.method_string.c_str(), authPairs["uri"].c_str()));
+
+ std::string response;
+ if (authPairs.find("qop") != authPairs.end() &&
+ authPairs.find("nc") != authPairs.end() &&
+ authPairs.find("cnonce") != authPairs.end()) {
+ response = base::MD5String(base::StringPrintf(
+ "%s:%s:%s:%s:%s:%s", hash1.c_str(), nonce.c_str(),
+ authPairs["nc"].c_str(), authPairs["cnonce"].c_str(),
+ authPairs["qop"].c_str(), hash2.c_str()));
+ } else {
+ response = base::MD5String(base::StringPrintf(
+ "%s:%s:%s", hash1.c_str(), nonce.c_str(), hash2.c_str()));
+ }
+
+ if (authPairs["response"] == response)
+ authed = true;
+ else
+ error = "wrong password";
+ }
+ }
+
+ if (!authed) {
+ http_response->set_code(HTTP_UNAUTHORIZED);
+ http_response->set_content_type("text/html");
+ std::string authHeader = base::StringPrintf(
+ "Digest realm=\"%s\", "
+ "domain=\"/\", qop=\"auth\", algorithm=MD5, nonce=\"%s\", "
+ "opaque=\"%s\"",
+ realm.c_str(), nonce.c_str(), opaque.c_str());
+ http_response->AddCustomHeader("WWW-Authenticate", authHeader);
+ http_response->set_content(base::StringPrintf(
+ "<html><head><title>Denied: %s</title></head>"
+ "<body>auth=%s<p>"
+ "You sent:<br>%s<p>We are replying:<br>%s<p></body></html>",
+ error.c_str(), auth.c_str(), request.all_headers.c_str(),
+ authHeader.c_str()));
+ return http_response.Pass();
+ }
+
+ http_response->set_content_type("text/html");
+ http_response->set_content(
+ base::StringPrintf("<html><head><title>%s/%s</title></head>"
+ "<body>auth=%s<p></body></html>",
+ username.c_str(), password.c_str(), auth.c_str()));
+
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleServerRedirect(const HttpRequest& request) {
+ GURL request_gurl = request.GetURL();
+ std::string dest =
+ net::UnescapeURLComponent(request_gurl.query(), kUnescapeAll);
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_MOVED_PERMANENTLY);
+ http_response->AddCustomHeader("Location", dest);
+ http_response->set_content_type("text/html");
+ http_response->set_content(base::StringPrintf(
+ "<html><head></head><body>Redirecting to %s</body></html>",
+ dest.c_str()));
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleCrossSiteRedirect(EmbeddedTestServer* server,
+ const HttpRequest& request) {
+ if (!ShouldHandle(request, "/cross-site"))
+ return nullptr;
+
+ std::string destAll = net::UnescapeURLComponent(
+ request.relative_url.substr(std::string("/cross-site").size() + 1),
+ kUnescapeAll);
+
+ std::string dest = base::StringPrintf(
+ "//%s:%hu/%s", destAll.substr(0, destAll.find("/")).c_str(),
+ server->port(), destAll.substr(destAll.find("/") + 1).c_str());
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_MOVED_PERMANENTLY);
+ http_response->AddCustomHeader("Location", dest);
+ http_response->set_content_type("text/html");
+ http_response->set_content(base::StringPrintf(
+ "<html><head></head><body>Redirecting to %s</body></html>",
+ dest.c_str()));
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleClientRedirect(const HttpRequest& request) {
+ GURL request_gurl = request.GetURL();
+ std::string dest =
+ net::UnescapeURLComponent(request_gurl.query(), kUnescapeAll);
+
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/html");
+ http_response->set_content(base::StringPrintf(
+ "<html><head><meta http-equiv=\"refresh\" content=\"0;url=%s\"></head>"
+ "<body>Redirecting to %s</body></html>",
+ dest.c_str(), dest.c_str()));
+ return http_response.Pass();
+}
+
+scoped_ptr<HttpResponse> HandleDefaultResponse(const HttpRequest& request) {
+ scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse);
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/html");
+ http_response->set_content("Default response given for path: " +
+ request.relative_url);
+ return http_response.Pass();
+}
+
+class DelayedHttpResponse : public BasicHttpResponse {
+ public:
+ DelayedHttpResponse(double delay) : delay_(delay) {}
+
+ void SendResponse(const SendBytesCallback& send,
+ const SendCompleteCallback& done) override {
+ base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+ FROM_HERE, base::Bind(send, ToResponseString(), done),
+ base::TimeDelta::FromSecondsD(delay_));
+ }
+
+ private:
+ double delay_;
+};
+
+scoped_ptr<HttpResponse> HandleSlowServer(const HttpRequest& request) {
+ double delay = 1.0f;
+
+ GURL request_gurl = request.GetURL();
+ if (request_gurl.has_query()) {
+ delay = std::atof(request_gurl.query().c_str());
+ }
+
+ scoped_ptr<BasicHttpResponse> http_response(new DelayedHttpResponse(delay));
+ http_response->set_code(HTTP_OK);
+ http_response->set_content_type("text/plain");
+ http_response->set_content(base::StringPrintf("waited %.1f seconds", delay));
+ return http_response.Pass();
+}
+}
Bence 2015/10/27 14:47:36 Add newline above this line. Add two spaces and /
svaldez 2015/10/27 15:00:50 Done.
+
+void RegisterDefaultHandlers(EmbeddedTestServer* server) {
+ server->RegisterDefaultHandler(base::Bind(&HandleDefaultConnect));
+
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/cachetime", &HandleCacheTime));
+ server->RegisterDefaultHandler(
+ base::Bind(&HandleEchoHeader, "/echoheader", "no-cache"));
+ server->RegisterDefaultHandler(
+ base::Bind(&HandleEchoHeader, "/echoheadercache", "max-age=60000"));
+ server->RegisterDefaultHandler(PREFIXED_HANDLER("/echo", &HandleEcho));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/echotitle", &HandleEchoTitle));
+ server->RegisterDefaultHandler(PREFIXED_HANDLER("/echoall", &HandleEchoAll));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/set-cookie", &HandleSetCookie));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/set-many-cookies", &HandleSetManyCookies));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/expect-and-set-cookie", &HandleExpectAndSetCookie));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/set-header", &HandleSetHeader));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/nocontent", &HandleNoContent));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/close-socket", &HandleCloseSocket));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/auth-basic", &HandleAuthBasic));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/auth-digest", &HandleAuthDigest));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/server-redirect", &HandleServerRedirect));
+ server->RegisterDefaultHandler(base::Bind(&HandleCrossSiteRedirect, server));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/client-redirect", &HandleClientRedirect));
+ server->RegisterDefaultHandler(
+ PREFIXED_HANDLER("/defaultresponse", &HandleDefaultResponse));
+ server->RegisterDefaultHandler(PREFIXED_HANDLER("/slow", &HandleSlowServer));
+
+ // TODO(svaldez): HandleDownload
+ // TODO(svaldez): HandleDownloadFinish
+ // TODO(svaldez): HandleZipFile
+ // TODO(svaldez): HandleRangeReset
+ // TODO(svaldez): HandleSSLManySmallRecords
+ // TODO(svaldez): HandleChunkedServer
+ // TODO(svaldez): HandleGetSSLSessionCache
+ // TODO(svaldez): HandleGetChannelID
+ // TODO(svaldez): HandleGetClientCert
+ // TODO(svaldez): HandleClientCipherList
+ // TODO(svaldez): HandleEchoMultipartPost
+}
+
+} // namespace test_server
+} // namespace net
« net/test/embedded_test_server/default_handlers.h ('K') | « net/test/embedded_test_server/default_handlers.h ('k') | net/test/embedded_test_server/embedded_test_server.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698